diff --git a/.agents/skills/polyxml-benchmark-workflow/SKILL.md b/.agents/skills/polyxml-benchmark-workflow/SKILL.md index 9d76dd8..81dc9e0 100644 --- a/.agents/skills/polyxml-benchmark-workflow/SKILL.md +++ b/.agents/skills/polyxml-benchmark-workflow/SKILL.md @@ -66,3 +66,9 @@ description: Use when running, adding, or publishing PolyXML language and runtim revision order and repeat uncertain results before calling a regression. Check per-process medians as well as pooled samples; do not treat correlated samples as independent process repetitions or call noise a speedup. + +11. For runtime optimization experiments, consult + [polyxml-runtime-investigation](../polyxml-runtime-investigation/SKILL.md). + Its allocation and Callgrind consumers are diagnostic only. Confirm wins + with the uninstrumented Criterion runner, and anchor write-only filters as + `^serialization/` because `serialization` also matches deserialization. diff --git a/.agents/skills/polyxml-core-engine/SKILL.md b/.agents/skills/polyxml-core-engine/SKILL.md index 6320cee..86dd4b3 100644 --- a/.agents/skills/polyxml-core-engine/SKILL.md +++ b/.agents/skills/polyxml-core-engine/SKILL.md @@ -250,3 +250,27 @@ records need not be walked for lexical-list validation at the outer field when its value type cannot be a lexical list. Preserve all constraints, mutable-schema semantics and full read/write regressions; source inspection alone does not prove which change caused a measured slowdown. Keep generated and dynamic timings separate. + +## Runtime hot paths + +Active scalar parser state stores field or mixed-branch indices into the schema +owned by its stack frame. Resolve metadata at the end event rather than cloning +rich enum/pattern definitions per occurrence. Keep split text, nil and nested +mixed-content tests when changing this state. + +Scalar regex validation uses the private process-wide `pattern` cache, keyed by +the exact original pattern and preserving anchored matching. Compilation and +matching run outside its lock. The cache admits 16 entries and keys up to 4,096 +bytes; larger keys bypass caching. These bound entries and key retention, not +compiled-regex memory. At capacity it selects a victim using the existing +randomized hasher and an eviction nonce; FIFO would miss on every access for a +cycle of 17 patterns. Public schema metadata remains mutable before sharing, +so avoid cached flags that become stale after edits. + +The serializer writes directly into an append-only byte vector and checks for +lexical-list obligations before traversing repeated values. Ordinary nested +records validate their own fields. Lexical lists append tokens to one string; +retain whitespace-token rejection, escaping and empty-list behavior. + +For measured changes, use +[polyxml-runtime-investigation](../polyxml-runtime-investigation/SKILL.md). diff --git a/.agents/skills/polyxml-runtime-investigation/SKILL.md b/.agents/skills/polyxml-runtime-investigation/SKILL.md new file mode 100644 index 0000000..b43445f --- /dev/null +++ b/.agents/skills/polyxml-runtime-investigation/SKILL.md @@ -0,0 +1,44 @@ +--- +name: polyxml-runtime-investigation +description: Diagnose and experimentally optimize regressions in PolyXML's dynamic Rust XML runtime using allocation counts, instruction profiles, and same-host latency comparisons. +--- + +# Dynamic XML runtime investigation + +Read [the investigation toolkit](../../../benchmarks/rust-runtime-investigation/README.md) +for exact commands and diagnostic boundaries. Keep generated XML/Serde consumers +separate from the schema-driven `PolyValue` runtime. + +- Start with an explicit detached baseline and a committed candidate on a branch. + Keep core sources stable while consumers build and run. Retain small experiments + independently so a failed hypothesis can be backed out without losing evidence. +- Use the counting allocator to distinguish allocation growth from CPU work. + Requested bytes are cumulative requests, not peak or retained memory. Larger + schema types can grow a fixed frame reserve without increasing allocation count. +- Use Callgrind's `measured_region` toggle for a fixed operation count. Its simulated + instruction count identifies candidates; verify changes with uninstrumented + Criterion consumers. Extracting Valgrind locally is an option when installation + would unnecessarily change the host. +- Preflight companion tooling before timing. Even `uv run runner.py --help` can + synchronize and rebuild an editable binding. After preparing its environment, + use `uv run --no-sync` for companion runs. If a build overlaps timing, retain + and mark that attempt as contaminated, then repeat it. +- Run heavy work serially, with one Cargo worker and the repository memory cap. + Short comparisons screen hypotheses. Repeat retained improvements with longer + measurements, alternating revision order and preserving every raw sample. +- Anchor Criterion filters: `^serialization/` means writes only; `serialization` + also matches deserialization. Remove stale results only in the runner's owned + scratch directory before measurement, not from retained raw evidence. +- Check rich enums, patterns, lists and mixed branches alongside plain records. + Warm pattern-cache gains do not establish cold-start, churn or concurrent + throughput. Entry/key bounds do not constitute a compiled-regex byte budget. +- Preserve validation, errors, split Text/CData/GeneralRef handling, nil reads, + nesting and metadata mutation semantics. Borrow scalar metadata from the schema + owned by a frame instead of cloning rich scalar definitions per element. +- Include the 17-pattern cycle when changing eviction: a 16-entry FIFO has + systematic misses, while salted victim selection preserves reuse at the same + capacity. Confirm hot cases too; pressure improvements alone do not establish + universal throughput gains. +- Publish positive and negative experiments with exact source revisions, raw + evidence and remaining regressions. Run the full quality gate before pushing + the experiment branch; a branch request does not authorize a merge to main. diff --git a/benchmarks/README.md b/benchmarks/README.md index dca4793..d15ec09 100644 --- a/benchmarks/README.md +++ b/benchmarks/README.md @@ -36,6 +36,7 @@ equivalent) and never at this root. | :--- | :--- | :--- | :--- | | Rust core engine | [`crates/polyxml-core/benches/`](../crates/polyxml-core/benches/) | [Criterion.rs](https://github.com/bheisler/criterion.rs) | `cargo bench --bench core_benchmarks` | | Rust same-host XML/Serde regression | [`rust-xml-regression/`](rust-xml-regression/README.md) | Generated consumers + Criterion | See suite README | +| Rust runtime investigation | [`rust-runtime-investigation/`](rust-runtime-investigation/README.md) | Dynamic core constraints, allocations and instruction profiles | See suite README | | Rust tag dispatch | [`crates/polyxml-core/benches/`](../crates/polyxml-core/benches/) | [Criterion.rs](https://github.com/bheisler/criterion.rs) + `perf stat` | `cargo bench --bench tag_dispatch` ([results](../docs/benchmarks/rust-phf-dispatch.md)) | | Rust end-to-end dispatch | [`rust-phf-e2e/`](rust-phf-e2e/README.md) | Generated decoders | `./benchmarks/rust-phf-e2e/run.sh` | | Rust dispatch compile cost | [`rust-phf-compile/`](rust-phf-compile/README.md) | Sequential capped release builds, GNU time, size | See suite README | diff --git a/benchmarks/rust-runtime-investigation/.gitignore b/benchmarks/rust-runtime-investigation/.gitignore new file mode 100644 index 0000000..9280984 --- /dev/null +++ b/benchmarks/rust-runtime-investigation/.gitignore @@ -0,0 +1,2 @@ +target/ +__pycache__/ diff --git a/benchmarks/rust-runtime-investigation/README.md b/benchmarks/rust-runtime-investigation/README.md new file mode 100644 index 0000000..8c2e4f4 --- /dev/null +++ b/benchmarks/rust-runtime-investigation/README.md @@ -0,0 +1,115 @@ +# Dynamic Rust XML runtime investigation + +These tools diagnose the schema-driven `PolyValue` runtime. Generated Rust XML +and JSON/Serde consumers have separate suites in +[`rust-xml-regression`](../rust-xml-regression/README.md). + +Start from a committed core implementation and an explicit detached baseline. +Run builds, profiles and latency measurements serially through `scripts/memcap.sh`. +Preflight companion tools before timing: even `uv run ... --help` can rebuild an +editable extension. Use `uv run --no-sync` after preparing that environment. +The runners use one Cargo worker, systemd memory limits and disabled swap. Keep +source files stable until a comparison finishes; source revisions describe HEAD, +so an uncommitted core edit makes that identification incomplete. + +## Latency comparisons + +For plain records, use the current core harness for both revisions: + +```bash +python3 benchmarks/rust-xml-regression/run_core.py \ + --baseline ../polyxml-perf-control \ + --output benchmarks/rust-runtime-investigation/target/evidence/final-core \ + --rounds 3 --samples 100 --warmup 3 --measurement 5 +``` + +For scalar constraints and content-model validation, use the alternate harness: + +```bash +python3 benchmarks/rust-xml-regression/run_core.py \ + --baseline ../polyxml-perf-control \ + --harness benchmarks/rust-runtime-investigation/constraints.rs \ + --output benchmarks/rust-runtime-investigation/target/evidence/final-constraints \ + --rounds 3 --samples 100 --warmup 3 --measurement 5 +python3 benchmarks/rust-runtime-investigation/summarize.py \ + benchmarks/rust-runtime-investigation/target/evidence/final-constraints +``` + +Both harnesses check decoded values and XML round trips before timing. The +constraint harness measures 1,000 repeated values: a 16-member enum, one scalar +pattern, a string restriction with a pattern and length, lexical integer lists, +and a content regex. Pattern cases measure **warm reuse**, including value +validation but excluding the first compilation. They do not characterize cold +patterns, cache churn, many-pattern schemas or multithreaded throughput. + +Criterion filters are regexes: use `--filter '^serialization/'` for writes only. +The unanchored filter `serialization` also matches `deserialization`. The runner +clears its own Criterion directory before each process, retains separate results +and alternates baseline/candidate order. Short runs (`--rounds 2 --samples 50 +--warmup 1 --measurement 2`) screen hypotheses; confirm useful changes with longer +runs. The summarizer takes the median of independent process mean estimates and +retains each process's confidence interval and delta. It does not manufacture a +confidence interval across process repetitions. + +## Allocation diagnostics + +```bash +python3 benchmarks/rust-runtime-investigation/run.py \ + --repo ../polyxml-perf-control --label control \ + --output benchmarks/rust-runtime-investigation/target/evidence/control +python3 benchmarks/rust-runtime-investigation/run.py \ + --repo . --label candidate \ + --output benchmarks/rust-runtime-investigation/target/evidence/candidate +``` + +The standalone release consumer enables a counting allocator only around the +measured operation. It counts allocations, reallocations and requested bytes; +requested bytes are cumulative requests, **not peak RSS or retained memory**. +Schema construction, ten warmup operations, and correctness checks are outside +the counted region. The returned value or byte buffer is destroyed in that +region. Use count 0 for the sensor and 1,000/10,000 for catalogs. Diagnostic +binaries contain instrumentation even when counting is disabled; never use +these binaries for latency claims. Public schema/scalar/value sizes are recorded +to distinguish per-frame growth from per-value heap allocation. + +## Instruction profiles + +With Valgrind installed, profile the same consumer and fixed number of operations: + +```bash +scripts/memcap.sh valgrind --tool=callgrind --collect-atstart=no \ + --toggle-collect=measured_region \ + --callgrind-out-file=target/read.callgrind \ + --log-file=target/read-valgrind.txt --error-exitcode=93 \ + benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics \ + read 1000 25 instructions +callgrind_annotate --auto=no --inclusive=no --threshold=95 \ + target/read.callgrind > target/read-annotated.txt +``` + +`measured_region` is deliberately not inlined. Collection excludes startup and +warmup; the release consumer retains line tables for attribution. Callgrind +counts executed instructions in a simulation; those counts explain hypotheses, +but do not measure hardware cycles or prove a latency improvement. If Valgrind +is extracted into an isolated directory, set `VALGRIND_LIB` to its matching +`usr/libexec/valgrind` directory and invoke its executable by absolute path. + +Retain baseline and candidate profiles, source harnesses, lockfiles, build logs, +metadata, every Criterion sample and verification logs under a dated +`docs/benchmarks/data/` directory. Link the resulting report from the benchmark +index. Include experiments that failed to improve performance, and state what +remains slower than the historical baseline. + +`cache_boundaries.rs` is a second alternate harness for the cache's working-set +boundary: 1, 16, 17 and 64 distinct patterns, eight occurrences per pattern. +Reads cycle pattern keys to expose FIFO misses above capacity and compare +replacement policies. Writes visit each +field's eight occurrences consecutively, so they can still reuse each compiled +regex locally even when the full schema exceeds capacity. Run it with the same +`--harness` option and retain both cases; field order affects reuse. + +For the generated sensor control, run the XML/Serde regression runner and use +`python3 benchmarks/rust-runtime-investigation/summarize.py --generated DIR` on +its output directory. This computes each process's median of seven timing +samples, then the median across processes; it retains the process deltas. The +statistic differs from the Criterion process means above. diff --git a/benchmarks/rust-runtime-investigation/cache_boundaries.rs b/benchmarks/rust-runtime-investigation/cache_boundaries.rs new file mode 100644 index 0000000..96494dd --- /dev/null +++ b/benchmarks/rust-runtime-investigation/cache_boundaries.rs @@ -0,0 +1,70 @@ +use criterion::{ + criterion_group, criterion_main, BenchmarkId, Criterion, SamplingMode, Throughput, +}; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::{hint::black_box, sync::Arc}; + +// Cycle through more than the admitted cache capacity to compare eviction policies. +// Schema construction and correctness checks remain outside measurement. +fn fixture(patterns: usize) -> (Arc, Vec) { + let mut builder = ModelSchema::builder("Root"); + for i in 0..patterns { + builder = builder.field(FieldSchema::new( + format!("values{i}"), + format!("Value{i}").as_bytes(), + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(ScalarType::Pattern( + Box::new(ScalarType::String), + vec![format!("P{i}-[0-9]{{3}}")], + )))), + )); + } + let schema = builder.build(); + let mut xml = String::from(""); + for _ in 0..8 { + for i in 0..patterns { + xml.push_str(&format!("P{i}-123")); + } + } + xml.push_str(""); + let value = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap(); + for i in 0..patterns { + let values = value.get(&format!("values{i}")).unwrap().as_list().unwrap(); + assert_eq!(values.len(), 8); + assert!(values + .iter() + .all(|value| value.as_str() == Some(format!("P{i}-123").as_str()))); + } + let output = serialize("Root", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml.into_bytes()) +} + +fn benchmarks(c: &mut Criterion) { + for operation in ["cache_read", "cache_write"] { + let mut group = c.benchmark_group(operation); + group.sampling_mode(SamplingMode::Flat); + for patterns in [1, 16, 17, 64] { + let (schema, xml) = fixture(patterns); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_with_input( + BenchmarkId::new("active_patterns", patterns), + &patterns, + |b, _| { + b.iter(|| { + if operation == "cache_read" { + black_box(deserialize(black_box(&xml), Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize("Root", black_box(&value), &schema, None).unwrap()); + } + }); + }, + ); + } + group.finish(); + } +} +criterion_group!(benches, benchmarks); +criterion_main!(benches); diff --git a/benchmarks/rust-runtime-investigation/constraints.rs b/benchmarks/rust-runtime-investigation/constraints.rs new file mode 100644 index 0000000..92b0c13 --- /dev/null +++ b/benchmarks/rust-runtime-investigation/constraints.rs @@ -0,0 +1,98 @@ +use criterion::{ + criterion_group, criterion_main, BenchmarkId, Criterion, SamplingMode, Throughput, +}; +use polyxml::ir::RestrictionFacets; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize, PolyValue}; +use std::{hint::black_box, sync::Arc}; + +fn fixture(kind: &str, count: usize) -> (Arc, Vec) { + let scalar = match kind { + "enum" => ScalarType::Enum((0..16).map(|i| format!("STATE{i}")).collect()), + "pattern" => ScalarType::Pattern( + Box::new(ScalarType::String), + vec!["[A-Z]{3}[0-9]{3}".into()], + ), + "restricted" => ScalarType::Restricted( + Box::new(ScalarType::String), + Box::new(RestrictionFacets { + patterns: vec!["[A-Z]{3}[0-9]{3}".into()], + length: Some(6), + ..Default::default() + }), + ), + "list" => ScalarType::List(Box::new(ScalarType::Int)), + "content" => ScalarType::String, + _ => unreachable!(), + }; + let mut builder = ModelSchema::builder("Root").field(FieldSchema::new( + "values", + b"Value", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(scalar))), + )); + if kind == "content" { + builder = builder + .content_pattern(polyxml::schema::compile_content_pattern("(?:Value;)*").unwrap()); + } + let schema = builder.build(); + let mut xml = String::from(""); + for i in 0..count { + let value = match kind { + "enum" => format!("STATE{}", i % 16), + "pattern" | "restricted" => format!("ABC{:03}", i % 1000), + "list" => format!("{i} {} -1", i + 1), + _ => format!("record-{i}"), + }; + xml.push_str(&format!("{value}")); + } + xml.push_str(""); + let value = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap(); + let values = value.get("values").unwrap().as_list().unwrap(); + assert_eq!(values.len(), count); + for (i, value) in values.iter().enumerate() { + match kind { + "enum" => assert_eq!(value.as_str(), Some(format!("STATE{}", i % 16).as_str())), + "pattern" | "restricted" => { + assert_eq!(value.as_str(), Some(format!("ABC{:03}", i % 1000).as_str())) + } + "list" => assert_eq!( + value, + &PolyValue::List(vec![ + PolyValue::Int(i as i64), + PolyValue::Int(i as i64 + 1), + PolyValue::Int(-1) + ]) + ), + _ => assert_eq!(value.as_str(), Some(format!("record-{i}").as_str())), + } + } + let output = serialize("Root", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml.into_bytes()) +} +fn benchmarks(c: &mut Criterion) { + for operation in ["constraint_read", "constraint_write"] { + let mut group = c.benchmark_group(operation); + group.sampling_mode(SamplingMode::Flat); + for kind in ["enum", "pattern", "restricted", "list", "content"] { + let (schema, xml) = fixture(kind, 1000); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_function(BenchmarkId::new(kind, 1000), |b| { + if operation == "constraint_read" { + b.iter(|| { + black_box(deserialize(black_box(&xml), Arc::clone(&schema)).unwrap()) + }); + } else { + b.iter(|| { + black_box(serialize("Root", black_box(&value), &schema, None).unwrap()) + }); + } + }); + } + group.finish(); + } +} +criterion_group!(benches, benchmarks); +criterion_main!(benches); diff --git a/benchmarks/rust-runtime-investigation/diagnostics.rs b/benchmarks/rust-runtime-investigation/diagnostics.rs new file mode 100644 index 0000000..1fbe95d --- /dev/null +++ b/benchmarks/rust-runtime-investigation/diagnostics.rs @@ -0,0 +1,94 @@ +// Fixture definitions are extracted verbatim from core_benchmarks.rs by run.py. +include!("fixtures.rs"); + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +struct CountingAllocator; +static COUNTING: AtomicBool = AtomicBool::new(false); +static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static REALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static BYTES: AtomicUsize = AtomicUsize::new(0); + +// Diagnostic instrumentation only. The benchmark consumers use System directly. +unsafe impl GlobalAlloc for CountingAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc(layout) } + } + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc_zeroed(layout) } + } + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + REALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(new_size, Ordering::Relaxed); + } + unsafe { System.realloc(ptr, layout, new_size) } + } +} +#[global_allocator] +static ALLOCATOR: CountingAllocator = CountingAllocator; + +fn main() { + let args: Vec = std::env::args().collect(); + let operation = args.get(1).expect("read or write"); + let count: usize = args + .get(2) + .expect("0 for sensor, or catalog count") + .parse() + .unwrap(); + let iterations: usize = args.get(3).expect("iteration count").parse().unwrap(); + let mode = args.get(4).map(String::as_str).unwrap_or("allocations"); + let (schema, xml) = if count == 0 { + build_sensor_fixture() + } else { + build_catalog_fixture(count) + }; + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let root = if count == 0 { "Sensor" } else { "Catalog" }; + let output = serialize(root, &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + for _ in 0..10 { + if operation == "read" { + black_box(deserialize(&xml, Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize(root, &value, &schema, None).unwrap()); + } + } + COUNTING.store(mode == "allocations", Ordering::Relaxed); + measured_region(operation, iterations, &xml, &value, root, &schema); + COUNTING.store(false, Ordering::Relaxed); + println!("operation={operation},count={count},iterations={iterations},allocations={},reallocations={},requested_bytes={},input_bytes={},output_bytes={},field_schema_bytes={},scalar_type_bytes={},value_type_bytes={},poly_value_bytes={}", + ALLOCATIONS.load(Ordering::Relaxed), REALLOCATIONS.load(Ordering::Relaxed), BYTES.load(Ordering::Relaxed), xml.len(), output.len(), + std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::()); +} + +#[inline(never)] +#[no_mangle] +fn measured_region( + operation: &str, + iterations: usize, + xml: &[u8], + value: &polyxml::PolyValue, + root: &str, + schema: &Arc, +) { + for _ in 0..iterations { + if operation == "read" { + black_box(deserialize(black_box(xml), Arc::clone(schema)).unwrap()); + } else { + black_box(serialize(root, black_box(value), schema, None).unwrap()); + } + } +} diff --git a/benchmarks/rust-runtime-investigation/run.py b/benchmarks/rust-runtime-investigation/run.py new file mode 100644 index 0000000..26b8185 --- /dev/null +++ b/benchmarks/rust-runtime-investigation/run.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +"""Build identical allocation diagnostics against an explicit source checkout.""" + +import argparse +import json +import os +import platform +import subprocess +from pathlib import Path + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, required=True) + parser.add_argument("--label", required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + root = Path(__file__).resolve().parents[2] + repo = args.repo.resolve() + revision = subprocess.check_output( + ["git", "-C", str(repo), "rev-parse", "HEAD"], text=True + ).strip() + core_status = subprocess.check_output( + ["git", "-C", str(repo), "status", "--porcelain", "--", "crates/polyxml-core"], + text=True, + ) + if core_status: + parser.error("commit core changes before collecting diagnostics") + output = args.output.resolve() + output.mkdir(parents=True, exist_ok=True) + crate = root / "benchmarks/rust-runtime-investigation/target" / args.label + (crate / "src").mkdir(parents=True, exist_ok=True) + fixtures = ( + (root / "crates/polyxml-core/benches/core_benchmarks.rs") + .read_text() + .split("fn bench_deserialization")[0] + ) + fixtures = "\n".join( + line for line in fixtures.splitlines() if not line.startswith("use criterion::") + ) + (crate / "src/fixtures.rs").write_text(fixtures + "\n") + (crate / "src/main.rs").write_bytes( + (Path(__file__).parent / "diagnostics.rs").read_bytes() + ) + (crate / "Cargo.toml").write_text( + '[package]\nname="xml-diagnostics"\nversion="0.0.0"\nedition="2021"\n[workspace]\n[dependencies]\npolyxml={path=' + + json.dumps(str(repo / "crates/polyxml-core")) + + "}\n[profile.release]\ndebug=1\n" + ) + for name, source in [ + ("harness.rs", crate / "src/main.rs"), + ("fixtures.rs", crate / "src/fixtures.rs"), + ("Cargo.toml", crate / "Cargo.toml"), + ]: + (output / f"{args.label}-{name}").write_bytes(source.read_bytes()) + seed = root / "benchmarks/rust-xml-regression/target/core-current/Cargo.lock" + if seed.exists(): + (crate / "Cargo.lock").write_bytes(seed.read_bytes()) + env = os.environ | {"CARGO_BUILD_JOBS": "1", "POLYXML_MEMCAP_BACKEND": "systemd"} + with (output / f"{args.label}-build.txt").open("w") as log: + subprocess.run( + [ + str(root / "scripts/memcap.sh"), + "cargo", + "build", + "--release", + "--manifest-path", + str(crate / "Cargo.toml"), + ], + env=env, + stdout=log, + stderr=subprocess.STDOUT, + check=True, + ) + executable = crate / "target/release/xml-diagnostics" + with (output / f"{args.label}-allocations.txt").open("w") as log: + for count in [0, 1000, 10000]: + for operation in ["read", "write"]: + subprocess.run( + [ + str(root / "scripts/memcap.sh"), + str(executable), + operation, + str(count), + "1", + ], + env=env, + stdout=log, + stderr=subprocess.STDOUT, + check=True, + ) + (output / f"{args.label}.lock").write_bytes((crate / "Cargo.lock").read_bytes()) + (output / f"{args.label}-metadata.json").write_text( + json.dumps( + { + "revision": revision, + "core_status": core_status, + "os": platform.platform(), + "rustc": subprocess.check_output(["rustc", "-Vv"], text=True), + "executable": str(executable), + "profile": "release debug=1; allocation instrumentation; not used for latency numbers", + }, + indent=2, + ) + + "\n" + ) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/rust-runtime-investigation/summarize.py b/benchmarks/rust-runtime-investigation/summarize.py new file mode 100644 index 0000000..fd6fdc8 --- /dev/null +++ b/benchmarks/rust-runtime-investigation/summarize.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +"""Summarize an explicit experiment's independent Criterion process rounds.""" + +import argparse +import csv +import json +import statistics +from collections import defaultdict +from pathlib import Path + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("experiment", type=Path) + parser.add_argument("--generated", action="store_true") + args = parser.parse_args() + if args.generated: + summarize_generated(args.experiment) + return + metadata = json.loads((args.experiment / "metadata.json").read_text()) + records = {} + for file in sorted((args.experiment / "baseline-0").rglob("new/estimates.json")): + key = file.relative_to(args.experiment / "baseline-0") + estimates = { + label: [ + json.loads((args.experiment / f"{label}-{i}" / key).read_text())["mean"] + for i in range(metadata["rounds"]) + ] + for label in ["baseline", "current"] + } + values = { + label: [row["point_estimate"] for row in rows] + for label, rows in estimates.items() + } + old, new = ( + statistics.median(values[label]) for label in ["baseline", "current"] + ) + name = str(key.parent.parent) + records[name] = { + "baseline_ns": old, + "candidate_ns": new, + "delta_percent": (new / old - 1) * 100, + "speedup": old / new, + "process_deltas_percent": [ + (b / a - 1) * 100 + for a, b in zip(values["baseline"], values["current"], strict=True) + ], + "process_estimates": estimates, + } + print( + f"{name:45} {old / 1000:10.3f} -> {new / 1000:10.3f} us; {(new / old - 1) * 100:+.2f}%; {old / new:.2f}x" + ) + (args.experiment / "summary.json").write_text(json.dumps(records, indent=2) + "\n") + + +def summarize_generated(experiment): + records = defaultdict(lambda: defaultdict(list)) + for path in sorted(experiment.glob("*.csv")): + label, mode, _ = path.stem.split("-") + samples = defaultdict(list) + with path.open() as source: + for row in csv.DictReader(source): + samples[(row["operation"], row["count"])].append( + float(row["ns_per_op"]) + ) + for (operation, count), values in samples.items(): + records[(mode, operation, count)][label].append(statistics.median(values)) + summary = {} + for key, values in sorted(records.items()): + old, new = ( + statistics.median(values[label]) for label in ["baseline", "current"] + ) + name = "/".join(key) + summary[name] = { + "baseline_ns": old, + "candidate_ns": new, + "delta_percent": (new / old - 1) * 100, + "speedup": old / new, + "process_values_ns": values, + "process_deltas_percent": [ + (b / a - 1) * 100 + for a, b in zip(values["baseline"], values["current"], strict=True) + ], + "statistic": "median across process sample medians", + } + print( + f"{name:45} {old / 1000:10.3f} -> {new / 1000:10.3f} us; {(new / old - 1) * 100:+.2f}%" + ) + (experiment / "summary.json").write_text(json.dumps(summary, indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/benchmarks/rust-xml-regression/run_core.py b/benchmarks/rust-xml-regression/run_core.py index 7010ba3..b9b164a 100644 --- a/benchmarks/rust-xml-regression/run_core.py +++ b/benchmarks/rust-xml-regression/run_core.py @@ -19,16 +19,27 @@ def main(): parser.add_argument("--baseline", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) parser.add_argument("--rounds", type=int, default=2) + parser.add_argument("--samples", type=int, default=100) + parser.add_argument("--warmup", type=float, default=3) + parser.add_argument("--measurement", type=float, default=5) + parser.add_argument("--filter", default="") + parser.add_argument("--harness", type=Path) args = parser.parse_args() if args.rounds < 1: parser.error("--rounds must be positive") + if args.samples < 10 or args.warmup <= 0 or args.measurement <= 0: + parser.error("use at least 10 samples and positive warmup/measurement times") root = Path(__file__).resolve().parents[2] output = args.output.resolve() + if (output / "metadata.json").exists(): + parser.error("choose a new output directory to preserve earlier evidence") output.mkdir(parents=True, exist_ok=True) build = root / "benchmarks/rust-xml-regression/target" env = os.environ | {"CARGO_BUILD_JOBS": "1", "POLYXML_MEMCAP_BACKEND": "systemd"} # Use one harness for both revisions, with round-trip checks outside timing. - source = (root / "crates/polyxml-core/benches/core_benchmarks.rs").read_text() + source = ( + args.harness or root / "crates/polyxml-core/benches/core_benchmarks.rs" + ).read_text() source = source.replace( " (schema, xml)\n", ' let value = deserialize(&xml, Arc::clone(&schema)).unwrap();\n let output = serialize("Sensor", &value, &schema, None).unwrap();\n assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap());\n (schema, xml)\n', @@ -40,10 +51,27 @@ def main(): (output / "harness.rs").write_text(source) executables = {} revisions = {} + core_status = {} for label, repo in [("baseline", args.baseline.resolve()), ("current", root)]: revisions[label] = run( ["git", "-C", str(repo), "rev-parse", "HEAD"], capture_output=True ).stdout.strip() + core_status[label] = run( + [ + "git", + "-C", + str(repo), + "status", + "--porcelain", + "--", + "crates/polyxml-core", + ], + capture_output=True, + ).stdout + if core_status[label]: + parser.error( + f"commit core changes before measuring {label}: {core_status[label]}" + ) crate = build / f"core-{label}" (crate / "benches").mkdir(parents=True, exist_ok=True) (crate / "benches/xml.rs").write_text(source) @@ -83,10 +111,12 @@ def main(): json.dumps( { "revisions": revisions, - "sample_size": 100, - "warmup_seconds": 3, - "measurement_seconds": 5, + "core_status": core_status, + "sample_size": args.samples, + "warmup_seconds": args.warmup, + "measurement_seconds": args.measurement, "rounds": args.rounds, + "filter": args.filter, "order": "alternate baseline/current per round", "os": platform.platform(), "cpu": Path("/proc/cpuinfo") @@ -104,6 +134,8 @@ def main(): ["baseline", "current"] if round_index % 2 == 0 else ["current", "baseline"] ): crate, executable = executables[label] + # A filter must not retain results from earlier unfiltered runs. + shutil.rmtree(crate / "target/criterion", ignore_errors=True) with (output / f"{label}-{round_index}.txt").open("w") as log: run( [ @@ -112,11 +144,12 @@ def main(): "--bench", "--noplot", "--sample-size", - "100", + str(args.samples), "--warm-up-time", - "3", + str(args.warmup), "--measurement-time", - "5", + str(args.measurement), + *([args.filter] if args.filter else []), ], cwd=crate, env=env, diff --git a/crates/polyxml-core/src/converters.rs b/crates/polyxml-core/src/converters.rs index 9ed8523..c1779c1 100644 --- a/crates/polyxml-core/src/converters.rs +++ b/crates/polyxml-core/src/converters.rs @@ -42,9 +42,7 @@ impl ValueConverter { && facets.min_length.is_none_or(|n| length >= n) && facets.max_length.is_none_or(|n| length <= n); for pattern in &facets.patterns { - valid &= regex::Regex::new(&format!("\\A(?:{pattern})\\z")) - .map(|r| r.is_match(text)) - .unwrap_or(false); + valid &= crate::pattern::matches(pattern, text); } for (bound, inclusive, minimum) in [ (&facets.min_inclusive, true, true), @@ -120,11 +118,7 @@ impl ValueConverter { ScalarType::Pattern(base, patterns) => { let value = std::str::from_utf8(trim_bytes(bytes))?; for pattern in patterns { - let anchored = format!(r"\A(?:{pattern})\z"); - if !regex::Regex::new(&anchored) - .map(|compiled| compiled.is_match(value)) - .unwrap_or(false) - { + if !crate::pattern::matches(pattern, value) { return Err(PolyXmlError::ScalarParseError { field: field_name.to_string(), expected: "pattern", diff --git a/crates/polyxml-core/src/lib.rs b/crates/polyxml-core/src/lib.rs index dac0fd9..3204ce8 100644 --- a/crates/polyxml-core/src/lib.rs +++ b/crates/polyxml-core/src/lib.rs @@ -5,6 +5,7 @@ pub mod integer; pub mod ir; pub mod json; pub mod parser; +mod pattern; pub mod schema; pub mod schema_parser; pub mod serializer; diff --git a/crates/polyxml-core/src/parser.rs b/crates/polyxml-core/src/parser.rs index 891f033..afc027e 100644 --- a/crates/polyxml-core/src/parser.rs +++ b/crates/polyxml-core/src/parser.rs @@ -12,6 +12,11 @@ use crate::value::PolyValue; type NamespaceScope = Arc>; +enum ActiveScalar { + Field { index: usize, repeated: bool }, + Mixed { branch: usize }, +} + pub(crate) struct StackFrame { schema: Arc, values: SmallVec<[Option; 8]>, @@ -39,7 +44,7 @@ impl StackFrame { } } - fn push_mixed_item(&mut self, kind: &str, value: PolyValue) { + fn push_mixed_item(&mut self, kind: impl Into, value: PolyValue) { if let Some(mixed) = &self.schema.mixed_content { let mut item = HashMap::new(); item.insert("kind".into(), PolyValue::String(kind.into())); @@ -417,8 +422,7 @@ impl XmlDeserializer { Self::parse_attributes(root_start, &mut root_frame)?; stack.push(root_frame); - let mut active_scalar_field: Option<(usize, ScalarType, bool)> = None; - let mut active_mixed_scalar: Option<(String, ScalarType)> = None; + let mut active_scalar: Option = None; let mut unknown_depth: usize = 0; let mut any_stack: Vec = Vec::new(); let mut text_buf: Vec = Vec::new(); @@ -432,14 +436,11 @@ impl XmlDeserializer { unknown_depth += 1; continue; } - if active_scalar_field.is_none() - && active_mixed_scalar.is_none() - && any_stack.is_empty() - { + if active_scalar.is_none() && any_stack.is_empty() { let scope = namespace_stack.last().unwrap(); record_content_token(stack.last_mut().unwrap(), e, scope); } - if active_scalar_field.is_some() || active_mixed_scalar.is_some() { + if active_scalar.is_some() { unknown_depth = 1; continue; } @@ -476,24 +477,30 @@ impl XmlDeserializer { { let field = ¤t_schema.fields[field_idx]; match &field.val_type { - ValueType::Scalar(st) => { + ValueType::Scalar(_) => { if is_nil { stack.last_mut().unwrap().values[field_idx] = Some(PolyValue::Null); } else { - active_scalar_field = Some((field_idx, st.clone(), false)); + active_scalar = Some(ActiveScalar::Field { + index: field_idx, + repeated: false, + }); text_buf.clear(); } } ValueType::List(inner) => match inner.as_ref() { - ValueType::Scalar(st) => { + ValueType::Scalar(_) => { if is_nil { stack .last_mut() .unwrap() .push_list_item(field_idx, PolyValue::Null); } else { - active_scalar_field = Some((field_idx, st.clone(), true)); + active_scalar = Some(ActiveScalar::Field { + index: field_idx, + repeated: true, + }); text_buf.clear(); } } @@ -535,7 +542,12 @@ impl XmlDeserializer { } } } else if let Some(mixed) = ¤t_schema.mixed_content { - if let Some(branch) = mixed.branch(local_name.as_ref().as_bytes()) { + if let Some(branch_index) = mixed + .branches + .iter() + .position(|branch| branch.xml_name == local_name.as_ref().as_bytes()) + { + let branch = &mixed.branches[branch_index]; if is_nil { stack .last_mut() @@ -544,9 +556,10 @@ impl XmlDeserializer { unknown_depth = 1; } else { match &branch.val_type { - ValueType::Scalar(scalar) => { - active_mixed_scalar = - Some((branch.variant_name.clone(), scalar.clone())); + ValueType::Scalar(_) => { + active_scalar = Some(ActiveScalar::Mixed { + branch: branch_index, + }); text_buf.clear(); } ValueType::Nested(sub_schema) => { @@ -609,10 +622,7 @@ impl XmlDeserializer { } } Ok(Event::Empty(ref e)) => { - if unknown_depth > 0 - || active_scalar_field.is_some() - || active_mixed_scalar.is_some() - { + if unknown_depth > 0 || active_scalar.is_some() { continue; } if any_stack.is_empty() { @@ -789,7 +799,7 @@ impl XmlDeserializer { let raw = e.as_ref(); let raw_bytes = raw.as_bytes(); if memchr::memchr(b'&', raw_bytes).is_none() { - if active_scalar_field.is_some() || active_mixed_scalar.is_some() { + if active_scalar.is_some() { text_buf.extend_from_slice(raw_bytes); } else if let Some(frame) = stack.last_mut() { if let Some(ref mut tb) = frame.frame_text_buf { @@ -800,7 +810,7 @@ impl XmlDeserializer { } } else { let unescaped = quick_xml::escape::unescape(raw)?; - if active_scalar_field.is_some() || active_mixed_scalar.is_some() { + if active_scalar.is_some() { text_buf.extend_from_slice(unescaped.as_bytes()); } else if let Some(frame) = stack.last_mut() { if let Some(ref mut tb) = frame.frame_text_buf { @@ -821,7 +831,7 @@ impl XmlDeserializer { } continue; } - if active_scalar_field.is_some() || active_mixed_scalar.is_some() { + if active_scalar.is_some() { text_buf.extend_from_slice(e.as_ref().as_bytes()); } else if let Some(frame) = stack.last_mut() { if let Some(ref mut tb) = frame.frame_text_buf { @@ -853,16 +863,8 @@ impl XmlDeserializer { continue; } let frame_tb = stack.last_mut().and_then(|f| f.frame_text_buf.as_mut()); - if active_scalar_field.is_some() - || active_mixed_scalar.is_some() - || frame_tb.is_some() - { - append_general_ref( - e, - active_scalar_field.is_some() || active_mixed_scalar.is_some(), - &mut text_buf, - frame_tb, - )?; + if active_scalar.is_some() || frame_tb.is_some() { + append_general_ref(e, active_scalar.is_some(), &mut text_buf, frame_tb)?; } else { let mut resolved = Vec::new(); append_general_ref(e, true, &mut resolved, None)?; @@ -904,29 +906,57 @@ impl XmlDeserializer { } continue; } - if let Some((kind, scalar_type)) = active_mixed_scalar.take() { - let parsed = ValueConverter::parse_scalar(&scalar_type, &text_buf, &kind)?; - stack.last_mut().unwrap().push_mixed_item(&kind, parsed); - } else if let Some((field_idx, ref scalar_type, is_list)) = - active_scalar_field.take() - { - let field = &stack.last().unwrap().schema.fields[field_idx]; - let parsed_val = parse_field_scalar(scalar_type, &text_buf, field)?; + if let Some(active) = active_scalar.take() { let frame = stack.last_mut().unwrap(); - if is_list { - frame.push_list_item(field_idx, parsed_val); - } else { - frame.values[field_idx] = Some(parsed_val); + match active { + ActiveScalar::Field { index, repeated } => { + let field = &frame.schema.fields[index]; + // Schema metadata remains owned by the active frame. + let scalar_type = match &field.val_type { + ValueType::Scalar(scalar) => scalar, + ValueType::List(inner) => match inner.as_ref() { + ValueType::Scalar(scalar) => scalar, + _ => unreachable!( + "active scalar list has a scalar item type" + ), + }, + _ => unreachable!("active scalar field has a scalar type"), + }; + let parsed = parse_field_scalar(scalar_type, &text_buf, field)?; + if repeated { + frame.push_list_item(index, parsed); + } else { + frame.values[index] = Some(parsed); + } + } + ActiveScalar::Mixed { branch } => { + let branch = &frame + .schema + .mixed_content + .as_ref() + .expect("active mixed scalar has a content model") + .branches[branch]; + let ValueType::Scalar(scalar) = &branch.val_type else { + unreachable!("active mixed scalar has a scalar type"); + }; + let parsed = ValueConverter::parse_scalar( + scalar, + &text_buf, + &branch.variant_name, + )?; + let kind = branch.variant_name.clone(); + frame.push_mixed_item(kind, parsed); + } } } else if stack.len() > 1 { - let finished_frame = stack.pop().unwrap(); + let mut finished_frame = stack.pop().unwrap(); let local_name = e.local_name(); - let mixed_kind = finished_frame.mixed_parent_kind.clone(); + let mixed_kind = finished_frame.mixed_parent_kind.take(); let instance = finished_frame.finish()?; let parent = stack.last_mut().unwrap(); if let Some(kind) = mixed_kind { - parent.push_mixed_item(&kind, instance); + parent.push_mixed_item(kind, instance); continue; } diff --git a/crates/polyxml-core/src/pattern.rs b/crates/polyxml-core/src/pattern.rs new file mode 100644 index 0000000..0b05aad --- /dev/null +++ b/crates/polyxml-core/src/pattern.rs @@ -0,0 +1,155 @@ +//! Bounded process-wide reuse of anchored XML scalar patterns. +use std::collections::HashMap; +use std::hash::BuildHasher; +use std::sync::{Arc, OnceLock, RwLock}; + +const MAX_ENTRIES: usize = 16; +const MAX_KEY_BYTES: usize = 4096; + +#[derive(Clone)] +enum CompiledPattern { + Valid(Arc), + Invalid, +} + +impl CompiledPattern { + fn compile(pattern: &str) -> Self { + match regex::Regex::new(&format!(r"\A(?:{pattern})\z")) { + Ok(regex) => Self::Valid(Arc::new(regex)), + Err(_) => Self::Invalid, + } + } + + fn matches(&self, value: &str) -> bool { + match self { + Self::Valid(regex) => regex.is_match(value), + Self::Invalid => false, + } + } +} + +#[derive(Default)] +struct PatternCache { + entries: HashMap, + keys: Vec, + eviction_nonce: u64, +} + +impl PatternCache { + fn insert(&mut self, pattern: &str, compiled: CompiledPattern) { + if self.entries.len() == MAX_ENTRIES { + // FIFO misses on every access when a cycle exceeds capacity by one. + // Salt the victim selection with each eviction to break that cycle, + // using the existing randomized hasher without another dependency. + self.eviction_nonce = self.eviction_nonce.wrapping_add(1); + let victim = self + .entries + .hasher() + .hash_one((pattern, self.eviction_nonce)) as usize + % MAX_ENTRIES; + let displaced = self.keys.swap_remove(victim); + self.entries.remove(&displaced); + } + self.keys.push(pattern.into()); + self.entries.insert(pattern.into(), compiled); + } +} + +static CACHE: OnceLock> = OnceLock::new(); + +pub(crate) fn matches(pattern: &str, value: &str) -> bool { + // Bound entry and key retention without changing regex acceptance limits. + if pattern.len() > MAX_KEY_BYTES { + return CompiledPattern::compile(pattern).matches(value); + } + let cache = CACHE.get_or_init(|| RwLock::new(PatternCache::default())); + let cached = { + let guard = cache.read().unwrap_or_else(|poison| poison.into_inner()); + guard.entries.get(pattern).cloned() + }; + if let Some(compiled) = cached { + return compiled.matches(value); + } + + // Compilation and matching happen outside the lock. Concurrent misses can + // compile twice, but installation rechecks the key and retains one entry. + let compiled = CompiledPattern::compile(pattern); + let installed = { + let mut guard = cache.write().unwrap_or_else(|poison| poison.into_inner()); + if let Some(existing) = guard.entries.get(pattern) { + existing.clone() + } else { + guard.insert(pattern, compiled.clone()); + compiled + } + }; + installed.matches(value) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn bounded_cache_evicts_and_retains_invalid_results() { + let mut cache = PatternCache::default(); + cache.insert("[", CompiledPattern::compile("[")); + assert!(!cache.entries["["].matches("anything")); + for i in 0..MAX_ENTRIES { + let pattern = format!("VALUE{i}"); + cache.insert(&pattern, CompiledPattern::compile(&pattern)); + } + assert_eq!(cache.entries.len(), MAX_ENTRIES); + assert_eq!(cache.keys.len(), MAX_ENTRIES); + assert!(cache.entries["VALUE15"].matches("VALUE15")); + assert!(!cache.entries["VALUE15"].matches("VALUE150")); + } + + #[test] + fn cyclic_working_set_above_capacity_keeps_reusing_entries() { + let mut cache = PatternCache::default(); + let patterns: Vec<_> = (0..MAX_ENTRIES + 1).map(|i| format!("VALUE{i}")).collect(); + let operations = patterns.len() * 512; + let mut misses = 0; + for pattern in patterns.iter().cycle().take(operations) { + if !cache.entries.contains_key(pattern) { + misses += 1; + cache.insert(pattern, CompiledPattern::compile(pattern)); + } + assert!(cache.entries[pattern].matches(pattern)); + assert!(cache.entries.len() <= MAX_ENTRIES); + } + // A generous bound checks reuse rather than one random eviction order. + // FIFO would miss on every operation after the initial fill. + assert!( + misses < operations / 2, + "misses={misses}, operations={operations}" + ); + } + + #[test] + fn cache_matches_uncached_regex_under_churn_and_concurrency() { + let threads: Vec<_> = (0..4) + .map(|thread| { + std::thread::spawn(move || { + for i in 0..64 { + let pattern = format!("T{thread}-[0-9]{{{}}}", i % 8 + 1); + let text = format!("T{thread}-{}", "1".repeat(i % 8 + 1)); + assert!(matches(&pattern, &text)); + assert!(!matches(&pattern, &(text + "x"))); + } + }) + }) + .collect(); + for thread in threads { + thread.join().unwrap(); + } + assert!(!matches("[", "anything")); + assert!(matches("é+", "éé")); + assert!(!matches("é+", "é\n")); + assert!(matches( + &"a".repeat(MAX_KEY_BYTES + 1), + &"a".repeat(MAX_KEY_BYTES + 1) + )); + } +} diff --git a/crates/polyxml-core/src/serializer.rs b/crates/polyxml-core/src/serializer.rs index 3c30e48..f68ba99 100644 --- a/crates/polyxml-core/src/serializer.rs +++ b/crates/polyxml-core/src/serializer.rs @@ -1,6 +1,5 @@ use std::borrow::Cow; use std::collections::HashMap; -use std::io::Cursor; use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; use quick_xml::Writer; @@ -189,7 +188,7 @@ impl XmlSerializer { enable_namespaces: Option, ns_map: Option<&HashMap>, ) -> Result> { - let mut buffer = Cursor::new(Vec::with_capacity(512)); + let mut buffer = Vec::with_capacity(512); let mut writer = match indent { Some(spaces) => Writer::new_with_indent(&mut buffer, b' ', spaces), None => Writer::new(&mut buffer), @@ -210,9 +209,10 @@ impl XmlSerializer { schema.namespace.as_deref(), )?; - Ok(buffer.into_inner()) + Ok(buffer) } + #[inline] fn format_scalar_to<'a>( val: &'a PolyValue, buf: &'a mut [u8; lexical_core::BUFFER_SIZE], @@ -227,19 +227,34 @@ impl XmlSerializer { let bytes = lexical_core::write(*f, buf); std::str::from_utf8(bytes).ok().map(Cow::Borrowed) } - PolyValue::List(items) => { - let mut parts = Vec::with_capacity(items.len()); - for item in items { - let mut buffer = [0u8; lexical_core::BUFFER_SIZE]; - parts.push(Self::format_scalar_to(item, &mut buffer)?.into_owned()); - } - Some(Cow::Owned(parts.join(" "))) - } + PolyValue::List(items) => Self::format_lexical_list(items).map(Cow::Owned), PolyValue::Bool(b) => Some(Cow::Borrowed(if *b { "true" } else { "false" })), _ => None, } } + fn format_lexical_list(items: &[PolyValue]) -> Option { + let mut text = String::new(); + for (index, item) in items.iter().enumerate() { + let mut buffer = [0u8; lexical_core::BUFFER_SIZE]; + let part = Self::format_scalar_to(item, &mut buffer)?; + if index > 0 { + text.push(' '); + } + text.push_str(&part); + } + Some(text) + } + + #[inline] + fn has_lexical_list(ty: &ValueType) -> bool { + match ty { + ValueType::Scalar(ScalarType::List(_)) => true, + ValueType::List(inner) => Self::has_lexical_list(inner), + _ => false, + } + } + fn validate_lexical_list_items(ty: &ValueType, value: &PolyValue) -> Result<()> { if let ValueType::Scalar(ScalarType::List(_)) = ty { if let PolyValue::List(items) = value { @@ -258,8 +273,10 @@ impl XmlSerializer { )); } } else if let (ValueType::List(inner), PolyValue::List(items)) = (ty, value) { - for item in items { - Self::validate_lexical_list_items(inner, item)?; + if Self::has_lexical_list(inner) { + for item in items { + Self::validate_lexical_list_items(inner, item)?; + } } } Ok(()) @@ -333,9 +350,11 @@ impl XmlSerializer { }; for (index, field) in schema.fields.iter().enumerate() { - if let Some(value) = get_field(index, &field.name) { - crate::schema::validate_fixed(field, value)?; - Self::validate_lexical_list_items(&field.val_type, value)?; + if field.fixed_value.is_some() || Self::has_lexical_list(&field.val_type) { + if let Some(value) = get_field(index, &field.name) { + crate::schema::validate_fixed(field, value)?; + Self::validate_lexical_list_items(&field.val_type, value)?; + } } } diff --git a/crates/polyxml-core/tests/test_runtime_fast_paths.rs b/crates/polyxml-core/tests/test_runtime_fast_paths.rs new file mode 100644 index 0000000..c0f13f1 --- /dev/null +++ b/crates/polyxml-core/tests/test_runtime_fast_paths.rs @@ -0,0 +1,244 @@ +use std::collections::HashMap; +use std::sync::Arc; + +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize, PolyValue}; + +fn object(name: &str, value: PolyValue) -> PolyValue { + PolyValue::Object(HashMap::from([(name.into(), value)])) +} + +fn words(value: &str) -> PolyValue { + PolyValue::List(vec![PolyValue::String(value.into())]) +} + +#[test] +fn repeated_lexical_lists_keep_whitespace_validation() { + let schema = ModelSchema::builder("Root") + .field(FieldSchema::new( + "words", + b"Words", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(ScalarType::List(Box::new( + ScalarType::String, + ))))), + )) + .build(); + let valid = object( + "words", + PolyValue::List(vec![words("alpha"), words("beta")]), + ); + let output = serialize("Root", &valid, &schema, None).unwrap(); + assert_eq!(valid, deserialize(&output, Arc::clone(&schema)).unwrap()); + for invalid in [ + "two words", + "", + "line\nbreak", + "tab\tbreak", + "carriage\rreturn", + ] { + let value = object( + "words", + PolyValue::List(vec![words("alpha"), words(invalid)]), + ); + assert!(serialize("Root", &value, &schema, None) + .unwrap_err() + .to_string() + .contains("whitespace-separated list item")); + } +} + +#[test] +fn repeated_nested_records_validate_their_own_lexical_lists() { + let child = ModelSchema::builder("Child") + .field(FieldSchema::new( + "words", + b"Words", + FieldKind::Element, + ValueType::Scalar(ScalarType::List(Box::new(ScalarType::String))), + )) + .build(); + let schema = ModelSchema::builder("Root") + .field(FieldSchema::new( + "children", + b"Child", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(child))), + )) + .build(); + let valid = object( + "children", + PolyValue::List(vec![object("words", words("alpha"))]), + ); + let output = serialize("Root", &valid, &schema, None).unwrap(); + assert_eq!(valid, deserialize(&output, Arc::clone(&schema)).unwrap()); + let invalid = object( + "children", + PolyValue::List(vec![object("words", words("two words"))]), + ); + assert!(serialize("Root", &invalid, &schema, None) + .unwrap_err() + .to_string() + .contains("whitespace-separated list item")); +} + +#[test] +fn indexed_scalar_state_preserves_enum_pattern_and_split_text() { + let mut schema = ModelSchema::builder("Root") + .field(FieldSchema::new( + "states", + b"State", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(ScalarType::Enum(vec![ + "R&D".into(), + "Ready".into(), + ])))), + )) + .field(FieldSchema::new( + "code", + b"Code", + FieldKind::Element, + ValueType::Scalar(ScalarType::Pattern( + Box::new(ScalarType::String), + vec!["[A-Z]&[A-Z]".into()], + )), + )) + .build(); + let xml = b"R&ReadyA&"; + let value = deserialize(xml, Arc::clone(&schema)).unwrap(); + assert_eq!( + value.get("states"), + Some(&PolyValue::List(vec![ + PolyValue::String("R&D".into()), + PolyValue::String("Ready".into()) + ])) + ); + assert_eq!(value.get("code").and_then(PolyValue::as_str), Some("A&B")); + assert!(deserialize(b"invalid", Arc::clone(&schema)).is_err()); + assert!(deserialize(b"invalid", Arc::clone(&schema)).is_err()); + drop(value); + // Public schema metadata remains mutable before sharing the Arc. No stale plan. + Arc::get_mut(&mut schema).unwrap().fields[0].val_type = + ValueType::List(Box::new(ValueType::Scalar(ScalarType::Enum(vec![ + "Done".into() + ])))); + assert!(deserialize(b"Ready", Arc::clone(&schema)).is_err()); + assert!(deserialize(b"Done", schema).is_ok()); +} + +#[test] +fn cached_patterns_keep_raw_restriction_and_trimmed_pattern_semantics() { + use polyxml::converters::ValueConverter; + use polyxml::ir::RestrictionFacets; + let pattern = ScalarType::Pattern(Box::new(ScalarType::String), vec!["[A-Z]+".into()]); + let restriction = ScalarType::Restricted( + Box::new(ScalarType::String), + Box::new(RestrictionFacets { + patterns: vec!["[A-Z]+".into()], + ..Default::default() + }), + ); + for _ in 0..3 { + assert_eq!( + ValueConverter::parse_scalar(&pattern, b" AB ", "code").unwrap(), + PolyValue::String(" AB ".into()) + ); + assert!(ValueConverter::parse_scalar(&restriction, b" AB ", "code").is_err()); + assert!(ValueConverter::parse_scalar(&restriction, b"AB", "code").is_ok()); + assert!(ValueConverter::parse_scalar(&pattern, b"AB\nX", "code").is_err()); + let invalid = ScalarType::Pattern(Box::new(ScalarType::String), vec!["[".into()]); + assert!(ValueConverter::parse_scalar(&invalid, b"AB", "code").is_err()); + } + let mut schema = ModelSchema::builder("Root") + .field(FieldSchema::new( + "code", + b"Code", + FieldKind::Element, + ValueType::Scalar(pattern), + )) + .build(); + assert!(deserialize(b"AB", Arc::clone(&schema)).is_ok()); + Arc::get_mut(&mut schema).unwrap().fields[0].val_type = ValueType::Scalar(ScalarType::Pattern( + Box::new(ScalarType::String), + vec!["[0-9]+".into()], + )); + assert!(deserialize(b"AB", Arc::clone(&schema)).is_err()); + let value = deserialize(b"12", Arc::clone(&schema)).unwrap(); + serialize("Root", &value, &schema, None).unwrap(); + assert!(serialize( + "Root", + &object("code", PolyValue::String("AB".into())), + &schema, + None + ) + .is_err()); +} + +#[test] +fn lexical_list_formatting_preserves_escaping_empty_lists_and_long_numbers() { + let schema = ModelSchema::builder("Root") + .field(FieldSchema::new( + "words", + b"Words", + FieldKind::Element, + ValueType::Scalar(ScalarType::List(Box::new(ScalarType::String))), + )) + .field(FieldSchema::new( + "numbers", + b"Numbers", + FieldKind::Element, + ValueType::Scalar(ScalarType::List(Box::new(ScalarType::Int))), + )) + .build(); + for words in [ + vec![], + vec![ + PolyValue::String("<&".into()), + PolyValue::String("\"'".into()), + ], + ] { + let value = PolyValue::Object(HashMap::from([ + ("words".into(), PolyValue::List(words)), + ( + "numbers".into(), + PolyValue::List(vec![ + PolyValue::Int(i64::MIN), + PolyValue::Int(0), + PolyValue::Int(i64::MAX), + ]), + ), + ])); + for indent in [None, Some(2)] { + let output = serialize("Root", &value, &schema, indent).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + assert!(String::from_utf8(output) + .unwrap() + .contains("-9223372036854775808 0 9223372036854775807")); + } + } +} + +#[test] +fn unified_scalar_state_keeps_mixed_branch_order_nil_and_nested_frames() { + use polyxml::schema_parser::XsdParser; + let ir = XsdParser::new().parse_str(r#" + + + + + + + "#).unwrap(); + let schema = ModelSchema::from_ir(&ir, Some("Root")).unwrap(); + for document in [ + "startRemid-7Readyend", + "nestedafter0", + ] { + let value = deserialize(document.as_bytes(),Arc::clone(&schema)).unwrap(); + let output = serialize("Root",&value,&schema,None).unwrap(); + assert_eq!(value,deserialize(&output,Arc::clone(&schema)).unwrap()); + } + let nil_document = b"Ready"; + assert!(deserialize(nil_document, Arc::clone(&schema)).is_ok()); + assert!(deserialize(b"invalid", schema).is_err()); +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/README.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/README.txt new file mode 100644 index 0000000..19ac5f0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/README.txt @@ -0,0 +1,60 @@ +Dynamic Rust XML runtime investigation, October 3, 2026 + +Retained engine: 7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d +Control (0.34.6): bbbd087a9a8e9838a32912973cd4029c30f29c08 +Historical (0.27.0): cef575c11cc4f05e877ced157036f7ff53b8687b + +selected-core, selected-constraints, selected-cache-boundaries and +selected-old-core retain harnesses, locks, metadata, build/run logs, summaries +and samples.tar.gz. Each archive contains every original Criterion result file +for the six measured processes, including estimates and sample arrays. To +reconstruct a summary, extract samples.tar.gz in its comparison directory, then: + +python3 benchmarks/rust-runtime-investigation/summarize.py COMPARISON_DIRECTORY + +selected-generated retains every CSV, emitted model, lock, the common harness, +build logs and metadata for four rounds per revision/mode. For owned consumers, +the runner changes BatchType<'_> to BatchType in the common harness. Summarize: + +python3 benchmarks/rust-runtime-investigation/summarize.py --generated selected-generated + +screening.tar.gz retains exp1 through exp7 plus FIFO working-set and replacement +policy screens. These short runs select hypotheses; confirmation numbers are +in the selected-* directories. Exp1 retains writer results only; its unanchored +serialization filter also selected reads, but those read artifacts were not +retained and no read conclusion is drawn from that attempt. + +prototype-confirmation.tar.gz retains the earlier FIFO implementation's +comparisons and generated controls. Its final-core folder is excluded from +confirmation tables because a companion uv help invocation rebuilt an editable +binding during its last round. investigation-note.json records the exclusion; +final-core-clean repeats all three rounds, and selected-core subsequently tests +the retained replacement policy. Both generated controls are retained because +an initial apparent JSON batch-write slowdown did not repeat. + +archives.json records SHA-256 hashes, file counts and compressed sizes. Published +Criterion summaries were independently reconstructed from these archives and +checked for equality. This data does not contain benchmark binaries or downloaded +Valgrind packages. + +diagnostics/old, control, fifo and selected retain counting-allocator sources, +locks, counts, measured-region Callgrind files and annotations. Allocation +instrumentation is diagnostic only. Requested bytes are cumulative requests, +not peak RSS. Callgrind counts simulated instructions, not hardware cycles. +Counting is disabled in instruction-profile mode, so its printed allocation +zeros do not indicate allocation-free operations. + +verification retains the quality gate, refreshed companion CType output, +reference corpus output, tooling/docs checks and a minimal reproducer for two +unchanged correctness limitations. The corpus reference log has no source SHA; +its summary and group table match the refreshed run exactly. The failed corpus +preflight found no default release CLI; the actual sample explicitly placed the +fresh debug CLI on PATH. The companion lockfile was restored after refreshing +its editable extension, then the sample ran with uv --no-sync. + +All measured comparisons alternate revision order and run serially with systemd +memory caps and swap disabled. Core/constraint/cache confirmation: 3 processes, +100 samples, 3-second warmup, 5-second measurement targets. Generated controls: +4 process rounds per revision/mode, 100 warmup calls, 7 samples of at least 250ms. +Schema setup and correctness checks precede timing. Source, payload sizes, +toolchain and host details are in the accompanying report and metadata. diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/archives.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/archives.json new file mode 100644 index 0000000..659f465 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/archives.json @@ -0,0 +1,32 @@ +{ + "prototype-confirmation.tar.gz": { + "sha256": "4bb5860fe8fdb7cf8f73d39462cd6c912986995aa62eac75fd124902ef4df6ef", + "files": 1447, + "bytes": 367345 + }, + "screening.tar.gz": { + "sha256": "3a096fd3b001ca36fd137c12b5a702fe74d3785bc4b07329a3ee7c5f75839743", + "files": 1931, + "bytes": 382056 + }, + "selected-cache-boundaries/samples.tar.gz": { + "sha256": "ec9209b8895f3eb29a91fd9f52c1e009b7a50b27c9cd5a7d09f6925753e14f6c", + "files": 384, + "bytes": 56431 + }, + "selected-constraints/samples.tar.gz": { + "sha256": "84e4439facba3f926d20aab1843704c20496822962f4ebd9ad84100387579f9f", + "files": 480, + "bytes": 72214 + }, + "selected-core/samples.tar.gz": { + "sha256": "c6b469263f1e7e98ebb45b86558ceba9fea3f19b855a033b52a2d8ac455e140b", + "files": 288, + "bytes": 55440 + }, + "selected-old-core/samples.tar.gz": { + "sha256": "b031a7e6c35aba2a6809723d82e19ec1373afb4d769c9eb3b60b3c33818b2a02", + "files": 288, + "bytes": 55389 + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-Cargo.toml b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-Cargo.toml new file mode 100644 index 0000000..3928071 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-Cargo.toml @@ -0,0 +1,9 @@ +[package] +name="xml-diagnostics" +version="0.0.0" +edition="2021" +[workspace] +[dependencies] +polyxml={path="/home/bailey/github/polyxml-perf-control/crates/polyxml-core"} +[profile.release] +debug=1 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-allocations.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-allocations.txt new file mode 100644 index 0000000..25457ae --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-allocations.txt @@ -0,0 +1,12 @@ +memcap: <=7842 MiB (60% of 13070 MiB available) [systemd MemoryMax, swap off] +operation=read,count=0,iterations=1,allocations=12,reallocations=5,requested_bytes=11093,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7841 MiB (60% of 13069 MiB available) [systemd MemoryMax, swap off] +operation=write,count=0,iterations=1,allocations=2,reallocations=2,requested_bytes=554,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7841 MiB (60% of 13069 MiB available) [systemd MemoryMax, swap off] +operation=read,count=1000,iterations=1,allocations=5010,reallocations=1014,requested_bytes=717402,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7841 MiB (60% of 13068 MiB available) [systemd MemoryMax, swap off] +operation=write,count=1000,iterations=1,allocations=1001,reallocations=2007,requested_bytes=158560,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7841 MiB (60% of 13068 MiB available) [systemd MemoryMax, swap off] +operation=read,count=10000,iterations=1,allocations=50010,reallocations=10019,requested_bytes=7774738,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7845 MiB (60% of 13075 MiB available) [systemd MemoryMax, swap off] +operation=write,count=10000,iterations=1,allocations=10001,reallocations=20011,requested_bytes=2376640,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-build.txt new file mode 100644 index 0000000..5ffb0b0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-build.txt @@ -0,0 +1,3 @@ +memcap: <=7852 MiB (60% of 13088 MiB available) [systemd MemoryMax, swap off] + Compiling xml-diagnostics v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control) + Finished `release` profile [optimized + debuginfo] target(s) in 0.63s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-fixtures.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-fixtures.rs new file mode 100644 index 0000000..f231439 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-fixtures.rs @@ -0,0 +1,85 @@ +use std::hint::black_box; + +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + (catalog_schema, xml.into_bytes()) +} + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-harness.rs new file mode 100644 index 0000000..1fbe95d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-harness.rs @@ -0,0 +1,94 @@ +// Fixture definitions are extracted verbatim from core_benchmarks.rs by run.py. +include!("fixtures.rs"); + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +struct CountingAllocator; +static COUNTING: AtomicBool = AtomicBool::new(false); +static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static REALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static BYTES: AtomicUsize = AtomicUsize::new(0); + +// Diagnostic instrumentation only. The benchmark consumers use System directly. +unsafe impl GlobalAlloc for CountingAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc(layout) } + } + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc_zeroed(layout) } + } + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + REALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(new_size, Ordering::Relaxed); + } + unsafe { System.realloc(ptr, layout, new_size) } + } +} +#[global_allocator] +static ALLOCATOR: CountingAllocator = CountingAllocator; + +fn main() { + let args: Vec = std::env::args().collect(); + let operation = args.get(1).expect("read or write"); + let count: usize = args + .get(2) + .expect("0 for sensor, or catalog count") + .parse() + .unwrap(); + let iterations: usize = args.get(3).expect("iteration count").parse().unwrap(); + let mode = args.get(4).map(String::as_str).unwrap_or("allocations"); + let (schema, xml) = if count == 0 { + build_sensor_fixture() + } else { + build_catalog_fixture(count) + }; + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let root = if count == 0 { "Sensor" } else { "Catalog" }; + let output = serialize(root, &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + for _ in 0..10 { + if operation == "read" { + black_box(deserialize(&xml, Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize(root, &value, &schema, None).unwrap()); + } + } + COUNTING.store(mode == "allocations", Ordering::Relaxed); + measured_region(operation, iterations, &xml, &value, root, &schema); + COUNTING.store(false, Ordering::Relaxed); + println!("operation={operation},count={count},iterations={iterations},allocations={},reallocations={},requested_bytes={},input_bytes={},output_bytes={},field_schema_bytes={},scalar_type_bytes={},value_type_bytes={},poly_value_bytes={}", + ALLOCATIONS.load(Ordering::Relaxed), REALLOCATIONS.load(Ordering::Relaxed), BYTES.load(Ordering::Relaxed), xml.len(), output.len(), + std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::()); +} + +#[inline(never)] +#[no_mangle] +fn measured_region( + operation: &str, + iterations: usize, + xml: &[u8], + value: &polyxml::PolyValue, + root: &str, + schema: &Arc, +) { + for _ in 0..iterations { + if operation == "read" { + black_box(deserialize(black_box(xml), Arc::clone(schema)).unwrap()); + } else { + black_box(serialize(root, black_box(value), schema, None).unwrap()); + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-metadata.json new file mode 100644 index 0000000..1f70475 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control-metadata.json @@ -0,0 +1,5 @@ +{ + "revision": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "executable": "/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics", + "profile": "release debug=1; allocation instrumentation; not used for latency numbers" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control.lock new file mode 100644 index 0000000..1614ee2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/control.lock @@ -0,0 +1,317 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-diagnostics" +version = "0.0.0" +dependencies = [ + "polyxml", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-annotated.txt new file mode 100644 index 0000000..589c8a7 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-annotated.txt @@ -0,0 +1,213 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/control/read-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 89369042 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics read 1000 25 instructions (PID 331945, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +294,910,404 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +21,680,675 ( 7.35%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +13,926,225 ( 4.72%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +11,858,578 ( 4.02%) ???:0x00000000000b2400 [/usr/lib/x86_64-linux-gnu/libc.so.6] +10,868,100 ( 3.69%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +10,352,875 ( 3.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 9,327,200 ( 3.16%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:::parse_sub_tree::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 8,900,000 ( 3.02%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs: as core::hash::Hasher>::write [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 7,805,073 ( 2.65%) ???:0x00000000000b20e0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 6,602,200 ( 2.24%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 6,401,100 ( 2.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 5,426,700 ( 1.84%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs:::feed [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 5,127,950 ( 1.74%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,625,000 ( 1.57%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs:::hash_one::<&[u8]> + 4,403,350 ( 1.49%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,058,539 ( 1.38%) ???:0x00000000001972a0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 3,275,600 ( 1.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 3,176,175 ( 1.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::parse_sub_tree::<&[u8]> + 3,150,700 ( 1.07%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 3,001,875 ( 1.02%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 3,000,000 ( 1.02%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::hash_one::<&[u8]> + 2,875,000 ( 0.97%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/converters.rs:::parse_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,825,700 ( 0.96%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_sub_tree::<&[u8]> + 2,625,750 ( 0.89%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,550,000 ( 0.86%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:polyxml::parser::is_nil_element [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,475,825 ( 0.84%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:polyxml::parser::namespace_scope [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,414,886 ( 0.82%) ???:0x00000000000b0f70 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 2,375,000 ( 0.81%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::hash_one::<&[u8]> + 2,325,000 ( 0.79%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::check_for_duplicates [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,175,000 ( 0.74%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::next + 2,076,050 ( 0.70%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_start + 2,025,675 ( 0.69%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_end [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,025,675 ( 0.69%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_start [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 2,001,075 ( 0.68%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:::parse_attributes [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,950,800 ( 0.66%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,948,250 ( 0.66%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,925,000 ( 0.65%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::parse_sub_tree::<&[u8]> + 1,900,350 ( 0.64%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::next + 1,800,000 ( 0.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::parse_sub_tree::<&[u8]> + 1,558,400 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs:::parse_scalar + 1,500,150 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 1,500,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs:::hash_one::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,489,425 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,465,250 ( 0.50%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,450,000 ( 0.49%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs:::clone [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,366,800 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::next + 1,357,775 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,350,275 ( 0.46%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,350,000 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::grow_one [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,275,425 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs:::emit_end + 1,226,475 ( 0.42%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::finish + 1,225,425 ( 0.42%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:; 8]>>::from_elem + 1,200,400 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,200,000 ( 0.41%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:polyxml::parser::record_content_token [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,199,850 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 1,151,775 ( 0.39%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:::finish [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 1,150,300 ( 0.39%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:::feed + 1,075,300 ( 0.36%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 1,075,000 ( 0.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_sub_tree::<&[u8]> + 1,050,400 ( 0.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,050,300 ( 0.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:::feed + 1,050,300 ( 0.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_end + 1,000,150 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_sub_tree::<&[u8]> + 1,000,000 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 975,000 ( 0.33%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 950,100 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_scalar + 950,100 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::next + 900,525 ( 0.31%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 900,300 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 900,275 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_end + 900,100 ( 0.31%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 850,750 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_sub_tree::<&[u8]> + 850,150 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 850,000 ( 0.29%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::local_name [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 850,000 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::local_name + 825,025 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::parse_sub_tree::<&[u8]> + 800,575 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_start + 800,250 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 800,100 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:::parse_sub_tree::<&[u8]> + 800,000 ( 0.27%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:::new [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 775,475 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::finish + 750,250 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 750,250 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_start + 750,000 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::next + 750,000 ( 0.25%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::parse_sub_tree::<&[u8]> + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs: as core::hash::Hasher>::write + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs:::hash_one::<&[u8]> + 700,700 ( 0.24%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]>>::from_elem [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 700,250 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 700,225 ( 0.24%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:::push_list_item [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 675,675 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 675,225 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs:::parse_sub_tree::<&[u8]> + 675,225 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_start + 675,150 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 675,000 ( 0.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::unescape [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 675,000 ( 0.23%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:::parse_sub_tree::<&[u8]> + 675,000 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::find:: + 650,125 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::namespace_scope + 608,450 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::parse_scalar + 603,525 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 600,600 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,200 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,150 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:core::ptr::drop_glue::> + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::is_nil_element + 575,050 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs:::parse_sub_tree::<&[u8]> + 575,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs:::parse_scalar + 550,550 ( 0.19%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:polyxml::parser::resolve_record_schema [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 550,550 ( 0.19%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs:polyxml::schema::validate_content [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 550,350 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::finish + 550,000 ( 0.19%) /rust/deps/hashbrown-0.17.1/src/raw.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 525,175 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_end + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::check_for_duplicates + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::check_for_duplicates + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs:__rustc::__rust_alloc + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_alloc + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs:::try_fast_path:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_text [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::hash::Hasher>::write + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_attributes + 491,750 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs:::parse_scalar + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:>; 4]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 466,875 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 452,375 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 450,150 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_end + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::emit_start + 450,100 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs:::parse_scalar + 450,050 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 450,000 ( 0.15%) /rust/deps/hashbrown-0.17.1/src/map.rs:::parse_sub_tree::<&[u8]> + 450,000 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::find:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 425,850 ( 0.14%) ???:0x00000000000b2300 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 425,050 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::parse_sub_tree::<&[u8]> + 422,350 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 400,400 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 400,300 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,125 ( 0.14%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,100 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::feed + 400,000 ( 0.14%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs:polyxml::parser::parse_field_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 377,250 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 375,425 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_start + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:::parse_attributes + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::emit_start + 375,000 ( 0.13%) /rust/deps/hashbrown-0.17.1/src/map.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 375,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::next + 375,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::parse_scalar + 350,100 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::feed + 350,075 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::parse_sub_tree::<&[u8]> + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::push_mut [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::hash::Hasher>::write + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 325,050 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::parse_sub_tree::<&[u8]> + 300,300 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::into_boxed_slice [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 300,200 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::finish + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,075 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::namespace_scope + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::emit_end + 300,025 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /rust/deps/hashbrown-0.17.1/src/lib.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::is_nil_element + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::check_for_duplicates + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::parse_sub_tree::<&[u8]> + 291,750 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs:::next + 275,050 ( 0.09%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs:::parse_scalar + 275,050 ( 0.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_attributes + 275,000 ( 0.09%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs:::parse_scalar + 250,500 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:__rustc::__rust_alloc + 250,500 ( 0.08%) benchmarks/rust-runtime-investigation/target/control/src/main.rs:__rustc::__rust_alloc [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 250,475 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::finish + 250,000 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::parse_sub_tree::<&[u8]> + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:::parse_attributes + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::parse_attributes + 250,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_scalar + 226,525 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 225,225 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:polyxml::parser::resolve_record_schema + 225,100 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::push_list_item + 225,075 ( 0.08%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs:::finish + 225,050 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_end + 225,050 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs:::emit_end + 225,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::parse_sub_tree::<&[u8]> + 225,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs:::parse_sub_tree::<&[u8]> + 225,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:>>::grow_one + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-valgrind.txt new file mode 100644 index 0000000..0f88426 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-valgrind.txt @@ -0,0 +1,12 @@ +==331945== Callgrind, a call-graph generating cache profiler +==331945== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==331945== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==331945== Command: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics read 1000 25 instructions +==331945== Parent PID: 331936 +==331945== +==331945== For interactive control, run 'callgrind_control -h'. +==331945== +==331945== Events : Ir +==331945== Collected : 294910404 +==331945== +==331945== I refs: 294,910,404 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000.callgrind new file mode 100644 index 0000000..febdd31 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/read-1000.callgrind @@ -0,0 +1,3752 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 331945 +cmd: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics read 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 89369042 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 294910404 + + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4502) 0x00000000000b2300 +0 300600 +cfn=(4508) 0x00000000000b20e0 +calls=37105 0 +0 3083347 +0 125250 + +fn=(4128) (below main) +cfn=(4162) 0x000000000002a580 +calls=1 0 +0 294910404 + +fn=(4508) +0 4946685 +cfn=(4952) 0x00000000000b0f70 +calls=73313 0 +0 1086761 +0 2459238 +cfn=(4952) +calls=35010 0 +0 548102 +0 399150 + +fn=(4330) 0x00000000000b08d0 +0 120120 + +fn=(4488) 0x0000000000197a00 +0 21680675 + +fn=(4952) +0 2414886 + +fn=(4232) 0x00000000000b2400 +0 10553314 +cfn=(4952) +calls=35955 0 +0 780023 +0 1272808 +cfn=(4330) +calls=32761 0 +0 117485 +0 8432 +cfn=(4330) +calls=799 0 +0 2635 +0 24024 + +fn=(4878) free +0 597300 +cfn=(4508) +calls=73670 0 +0 6356589 +0 4530650 + +fn=(4226) malloc +0 796400 +cfn=(4232) +calls=73729 0 +0 12746428 +0 3606950 + +fn=(4460) 0x00000000000b4180 +0 1109825 +cfn=(4232) +calls=64 0 +0 12293 +0 325500 +cfn=(4502) +calls=37042 0 +0 3506272 +0 25225 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=63 0 +0 325 +0 150 +cfn=(4502) +calls=63 0 +0 2925 +0 4550 + +fn=(5744) 0x00000000001972a0 +0 4058539 + +fn=(4162) +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4176) main +calls=1 0 +0 294910404 + +fn=(4458) realloc +0 1670225 +cfn=(4460) +calls=38415 0 +0 4987065 +0 278025 + +ob=(3) +fl=(3) +fn=(4486) +0 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=110 0 +0 275 + +ob=(6) +fl=(52) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs +fn=(5734) ::hash_one::<&[u8]> +694 750000 ++5 125000 +fi=(53) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs +203 250000 +fi=(48) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs +84 125000 +fi=(53) +204 250000 +fi=(48) +84 625000 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +4058 375000 +fi=(53) +233 375000 +cfn=(5292) as core::hash::Hasher>::write +calls=185000 +23 +* 6875000 +* 500000 +cfn=(5292) +calls=185000 +23 +* 3650000 ++81 375000 +-2 250000 ++4 250000 +fi=(10) +2652 250000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +2215 125000 +fi=(10) +2652 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 250000 +fi=(53) +78 125000 +318 125000 ++2 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 500000 +fi=(53) +323 375000 +fe=(52) +702 625000 + +fl=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +fn=(4178) std::rt::lang_start_internal +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5136) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 294910404 +fe=(8) + +fn=(5136) +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5138) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 294910404 + +fl=(85) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs +fn=(5504) <&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: +211 1800600 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +3101 150050 +1032 300100 ++1 100 +cfi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +cfn=(5508) >::grow_one +calls=74 186 +* 4800 +fi=(32) +611 150050 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +1963 150050 +fi=(33) +1038 450150 +fi=(76) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs +137 150050 +fe=(85) ++86 150050 +0 450150 +232 450150 +cfi=(87) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs +cfn=(5516) ::feed +calls=222074 57 +* 14181000 +* 300100 +0 150050 +233 450150 +fi=(10) +1092 150050 +fi=(32) +616 150050 +fi=(33) +1461 150050 +fi=(10) +2689 150050 +fi=(32) +764 150050 +-94 150050 +fi=(33) +2981 300000 +0 150050 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 150050 +fi=(18) +573 750250 +cob=(2) +cfi=(2) +cfn=(4488) +calls=222074 0 +* 2200650 +* 300100 +fi=(33) +2986 450150 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +90 150050 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs +389 450150 +fe=(85) +239 600200 +fi=(44) +544 450150 +90 300100 +fe=(85) +240 300100 +cfi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +cfn=(5182) core::str::converts::from_utf8 +calls=222074 89 +* 12090575 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +0 300100 +2177 300100 +fe=(85) +253 1200400 +0 150050 +240 600200 +fi=(33) +0 50 +fi=(32) +672 300 +cfn=(5532) >::reserve::do_reserve_and_handle:: +calls=74 -14 +* 6600 +* 100 +fi=(33) +3101 50 +2981 50 +fe=(85) + +fl=(98) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs +fn=(6004) >; 4]>>::resize_with::<::push_list_item::{closure#0}> +1841 200 +1082 75 +-30 25 +0 25 +1846 75 +1082 50 +-17 25 +0 25 +1358 75 +0 50 +1230 50 +fi=(20) +970 25 +fi=(18) +1963 100 +fe=(98) +1237 25 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2144 25 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 50 +fi=(74) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/parser.rs +65 25 +fe=(98) +1082 50 +1217 25 +1856 200 + +fn=(5634) ; 8]>>::from_elem +2052 250250 ++1 50050 +856 25025 +fi=(18) +-9 25025 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fe=(98) +0 25025 +fi=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +2274 50050 ++2 25025 +fi=(18) +1963 400400 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fe=(98) +2615 50050 +2067 75075 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 ++2 225225 + +fn=(5958) ; 8]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(5984) >; 4]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +0 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(6142) >; 4]> as core::ops::drop::Drop>::drop +2483 250 ++10 50 +-8 200 + +fl=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +fn=(6150) >>::drop_slow +2138 75 ++6 25 +fi=(18) +842 25 ++5 25 +cfi=(55) /rust/deps/hashbrown-0.17.1/src/raw.rs +cfn=(6152) as core::ops::drop::Drop>::drop +calls=37 3486 +* 450 +fi=(119) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/rc.rs +3277 25 +fe=(59) +3392 25 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +4049 25 +fe=(59) +3544 25 +fi=(23) +175 175 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5684) __rustc::__rust_dealloc +calls=37 65 +* 850 +fe=(59) + +fl=(18) +fn=(5614) core::ptr::drop_glue::> +847 700200 +fi=(32) +425 350100 +631 175050 +425 75000 +fi=(10) +1401 75000 +fi=(23) +175 150000 +cfi=(26) +cfn=(5684) +calls=111000 65 +* 2550000 +fe=(18) +847 1925550 + +fn=(6416) core::ptr::drop_glue:: +847 275 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(18) +847 450 +cfn=(6417) core::ptr::drop_glue::'2 +calls=37 * +* 12447414 +* 200 +cob=(2) +cfi=(2) +cfn=(4878) +calls=37 0 +* 825 + +fn=(6417) +847 275 +fi=(32) +611 25 +fi=(33) +4358 25 +fe=(18) +847 125 +0 25 +847 50 +cfn=(6417) +calls=37 * +* 8314 +* 49950 +cfn=(6417) +calls=36963 * +* 12284032 +* 100000 +fi=(32) +631 50 +fe=(18) +847 175 +cob=(2) +cfi=(2) +cfn=(4878) +calls=37 0 +* 4368 +* 1700000 +fi=(32) +631 50000 +425 25000 +fi=(23) +312 25000 +fi=(14) +454 25000 +fi=(13) +4049 25000 +fi=(59) +2868 25000 +fe=(18) +847 900000 +cfn=(6417) +calls=111000 * +* 6176136 +* 525000 +cob=(2) +cfi=(2) +cfn=(4878) +calls=74000 0 +* 8992346 + +fn=(5896) core::ptr::drop_glue:: +847 1000000 + +fl=(45) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs +fn=(5808) ::clone +13 1450000 + +fn=(5926) polyxml::schema::validate_content +725 200200 ++1 100100 +0 25025 +735 225225 + +fl=(87) +fn=(5516) +57 1500500 +fi=(54) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs +473 450150 +fi=(13) +3994 300100 +fi=(78) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs +153 900300 +cfi=(84) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs +cfn=(5522) memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 +calls=222073 1042 +* 4203450 +fi=(41) +2869 300100 +fi=(88) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs +0 150050 +fi=(54) +623 300100 +fe=(87) +59 300100 +fi=(54) +871 150050 +fe=(87) +59 625200 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5522) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fi=(88) +0 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 375100 +-59 150050 +59 600200 +-59 150050 +59 200050 ++14 1350450 +fi=(88) +-73 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 75000 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5522) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fe=(87) + +fl=(108) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/converters.rs +fn=(5782) ::parse_scalar +28 900000 ++5 900000 +fi=(76) +-33 25000 +cfi=(38) +cfn=(5182) +calls=37000 89 +0 1961250 +0 50000 +fi=(27) +2177 50000 +fi=(111) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/lib.rs +0 25000 +fi=(47) +478 25000 +fi=(32) +-17 25000 +0 25000 +cfi=(6) +cfn=(5100) __rustc::__rust_no_alloc_shim_is_unstable_v2 +calls=37000 0 +0 25000 +0 25000 +fi=(23) +130 75000 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/src/main.rs +cfn=(5102) __rustc::__rust_alloc +calls=37000 -89 +* 10653953 +fi=(32) +470 50000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +0 25000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 330000 +fi=(36) +452 25000 +fi=(76) +0 25000 +199 100000 +fi=(56) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs +434 75000 +0 25000 +434 75000 +fi=(18) +0 50000 +fe=(108) +138 50000 +0 100000 +fi=(76) +199 50000 +0 100000 +fi=(56) +434 75000 +fi=(32) +0 125000 +fe=(108) +95 25000 +fi=(56) +434 150000 +fi=(76) +0 25000 +fi=(56) +434 175000 +fi=(112) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs +175 100000 +fi=(109) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs ++24 175000 +fi=(44) +0 150000 +fi=(113) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs +252 125000 +0 50000 +fi=(44) +184 50000 +0 50000 +fi=(112) +872 50000 +fi=(10) +2689 25000 +fi=(126) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +39 50000 +fi=(112) +872 155600 +fi=(10) +2689 77800 +fi=(126) +39 155600 +fi=(10) +2728 155600 +fi=(112) +566 77800 +fi=(10) +2652 77800 +fi=(110) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs +144 77800 +fi=(44) ++40 155600 +fi=(109) +677 25000 ++10 25000 +0 75000 +411 50000 +fi=(10) +2689 25000 +fi=(126) +39 50000 +fi=(109) +-39 47250 +411 94500 +fi=(10) +2689 47250 +fi=(126) +39 94500 +fi=(110) +270 72250 +fi=(145) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 72250 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +132 72250 +fi=(145) +2189 72250 +fi=(44) +184 144500 +0 25000 +fe=(108) +160 75000 +-65 25000 +fi=(19) +2105 25000 +fi=(112) +616 25000 +0 50000 +fi=(44) +380 25000 +fi=(113) +252 100000 +fi=(44) +-68 50000 +0 50000 +fi=(112) +872 100000 +fi=(10) +2689 50000 +fi=(126) +39 100000 +fi=(10) +2728 100000 +fi=(112) +623 50000 +fi=(10) +2652 50000 +fi=(110) +144 50000 +fi=(44) ++40 100000 +0 50000 +90 50000 +fi=(112) +616 225000 +fe=(108) +0 25000 +fi=(112) +568 100000 +fi=(44) +184 50000 +fi=(110) +0 75000 +fi=(112) +666 50000 +0 25000 +666 25000 ++81 50000 +0 25000 +747 25000 +855 50000 +216 300000 ++51 25000 +cfi=(114) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs +cfn=(5908) ::try_fast_path:: +calls=37000 45 +* 675000 +* 50000 +fe=(108) +-97 75000 +-75 25000 +215 675000 + +fl=(30) +fn=(5138) +fi=(143) +cfi=(24) +cfn=(5140) xml_diagnostics::main +calls=1 43 +250 294910404 +fe=(30) + +fl=(90) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs +fn=(5554) ::emit_start +314 750250 +fi=(92) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs ++70 150050 +fi=(43) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs +1229 75025 +fi=(91) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs +493 75025 +0 75025 +221 150050 +fi=(76) +2736 150050 +fi=(77) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs +157 75025 +fi=(76) +2738 75025 +0 75025 +2738 75025 +fe=(90) +345 150050 +fi=(10) +1092 75025 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 75025 +fi=(91) +424 75025 +0 225075 +fi=(93) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs +331 325175 +-4 650350 ++1 700350 +-13 350175 +0 50000 +fi=(33) +3101 25000 +1029 25000 ++3 50000 +fi=(32) +611 75025 +fi=(18) +1963 75025 +fi=(33) +1038 150050 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 25000 +fi=(91) +424 25000 +fi=(33) +1033 100 +cfi=(32) +cfn=(5570) >::grow_one +calls=37 186 +* 2675 +* 75 +0 50025 +3101 50025 +1029 50025 ++3 100075 +fi=(91) +424 50025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +0 75025 +fi=(20) +970 75025 +fi=(18) +573 300100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=111037 0 +* 1125375 +* 75025 +fi=(33) +2986 225075 +fe=(90) +0 450150 +356 675225 +fi=(32) +672 250 +cfn=(5532) +calls=74 -14 +* 5825 +* 50 +fi=(33) +3101 100 +fe=(90) + +fn=(5816) ::emit_text +63 50000 ++1 100000 ++11 200000 ++1 150000 + +fn=(5850) ::emit_end +197 525175 +fi=(91) +-68 150050 +fi=(43) +1229 75025 +fi=(91) +145 75025 +fi=(43) +1229 75025 +fi=(91) +262 75025 +0 300100 +fe=(90) +214 225075 +fi=(93) +315 300100 +0 75025 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +402 150050 +fi=(93) +-87 75025 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fe=(90) +228 150050 +fi=(32) +611 75025 +fi=(33) +1865 75025 +fi=(92) +380 150050 ++4 150000 +fi=(43) +1229 75000 +fi=(91) +493 75000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1490 150050 +fi=(92) +380 450150 +fi=(32) +611 75000 +fi=(43) +1229 75000 +fi=(40) +1491 75000 +fi=(33) +1828 75025 +fe=(90) +257 375125 ++1 675225 +fi=(92) +384 225075 +fi=(91) +221 150050 +fi=(54) +871 75025 +fi=(77) +21 150050 +-21 75025 +157 600200 +cob=(2) +cfi=(2) +cfn=(5744) +calls=111037 0 +* 1617539 +* 450150 +fe=(90) ++73 75025 +fi=(92) +394 75025 +fi=(91) ++30 75025 +fe=(90) + +fl=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +fn=(5714) ::local_name +141 250000 ++69 250000 +fi=(10) +1096 100000 +fi=(44) +90 50000 +fi=(102) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs +-62 100000 ++13 100000 +-41 100000 +42 200000 ++4 100000 +-5 250000 +fi=(54) +-41 50000 +fe=(103) +143 350000 + +fl=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(5770) quick_xml::escape::unescape +236 250000 ++52 25000 +fi=(54) +473 75000 +0 25000 +fi=(13) +3994 50000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5492) memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 +calls=37000 659 +* 1053000 +fi=(41) +2869 50000 +fe=(107) +321 50000 +fi=(91) +0 25000 +fe=(107) +327 100000 +0 25000 +238 225000 + +fl=(84) +fn=(5492) +659 350100 +fi=(78) +0 700200 +fi=(54) +623 350100 +fe=(84) ++40 350100 ++1 50100 +fi=(88) +1161 50050 +0 25025 +1162 25025 +fe=(84) +668 50050 +fi=(88) +1162 47250 +fe=(84) +668 239000 +fi=(54) +389 72250 +fi=(88) +1161 144500 +0 25000 +fi=(78) +86 75000 +fi=(18) +573 150000 +fi=(146) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs +699 300000 +2315 150000 +2163 150000 +fi=(147) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/vector.rs +147 150000 +fi=(88) +679 150000 +fi=(18) +573 25 +fi=(57) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs +920 50 +-25 25 +1569 25 +fi=(147) +147 25 +fi=(88) +679 25 +fe=(84) +0 450075 +fi=(78) +86 300100 +fe=(84) + +fn=(5522) +1042 400100 +0 1400350 +fi=(54) +623 400100 +fe=(84) +1046 400100 ++1 150 +fi=(88) +1161 50 +0 25 +1162 50 +fe=(84) +1051 25 +fi=(88) +1162 400 +fe=(84) +1051 1050 +fi=(54) +389 200 +fi=(88) +1161 400 +fi=(18) +573 199975 +fi=(146) +699 399950 +2315 199975 +699 199975 +2315 199975 +2163 199975 +fi=(147) +147 199975 +fi=(88) +972 199975 +fi=(18) +573 50 +fi=(57) +920 100 +-25 50 ++25 50 +-25 50 +1569 50 +fi=(147) +147 50 +fi=(88) +972 50 +fe=(84) +0 800100 +fi=(78) +86 400050 +-86 25 +86 50 +fe=(84) + +fl=(117) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs +fn=(5946) > as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter +32 200200 +fi=(98) +2493 100100 +0 25025 +2498 50050 +1082 25025 +-30 25025 +fi=(37) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs +0 25025 +26 225225 +fi=(98) +2506 25025 +fi=(10) +-10 75075 +fi=(19) +1051 75075 +fi=(10) +3212 25025 +fi=(37) +0 25025 +fi=(47) +478 75075 +fi=(98) +1052 25025 +fi=(54) +871 25025 +fi=(18) +1755 25025 +fi=(37) +24 50050 +fe=(117) ++10 200200 +fi=(32) +461 50050 +0 25025 +cfi=(6) +cfn=(5100) +calls=37037 0 +0 25025 +0 25025 +fi=(23) +130 75075 +cfi=(24) +cfn=(5102) +calls=37037 -89 +* 4837200 +fi=(32) +470 50050 +0 50050 +fi=(18) +1963 200200 +fi=(37) +36 100100 ++5 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 -41 +* 1926925 +fi=(98) +2493 125125 +0 50 +2493 50 +0 100000 +fi=(33) +4100 225000 +fi=(18) +1963 400000 +fi=(33) +4111 50000 +2224 50000 +fi=(98) +2493 150000 ++5 100000 +fi=(18) +1755 50000 +fi=(33) +4100 550000 ++2 100000 +fi=(98) +0 75000 +2493 50000 +0 25025 +fi=(18) +847 25025 +cfi=(98) +cfn=(5958) +calls=37037 2373 +* 525525 +fi=(37) +42 150150 +fe=(117) + +fl=(114) +fn=(5908) +45 75000 +-45 25000 +46 50000 +-46 50000 +46 100000 ++36 50000 +fi=(115) ++70 50000 +fe=(114) +-67 50000 ++22 25000 +fi=(116) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/table_decimal.rs +-30 75000 +fi=(148) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/arith.rs +515 50000 +fe=(114) +100 75000 + +fl=(75) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs +fn=(5470) >::read_event_impl::<&mut alloc::vec::Vec> +1006 2400600 +289 1400350 +fi=(76) +2635 50 +fi=(77) +157 125 +fi=(85) +24 25 +fe=(75) +306 25 ++45 300100 +fi=(33) +3101 150050 +fi=(76) +137 300100 +0 300100 +fi=(54) +871 150050 +fi=(13) +3994 300100 +fi=(78) +153 750250 +cfi=(84) +cfn=(5492) +calls=222073 659 +* 3301100 +fi=(41) +2869 300100 +fi=(85) +72 600200 ++7 100000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 100000 +-94 50000 +fi=(20) +970 50000 +fi=(18) +573 200000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +* 100000 +fi=(33) +2986 100000 +fi=(85) +0 50000 +fi=(44) +549 100000 +fi=(144) +389 100000 +fi=(44) +544 50000 +fi=(85) +79 100000 +fi=(44) +544 150000 +90 100000 +fi=(85) +-4 150000 +cfi=(38) +cfn=(5182) +calls=74000 +3 +* 3700250 +* 100000 +-25 150000 ++14 100050 +fi=(144) +389 100050 +fe=(75) +-34 100050 +0 300150 +437 100050 +fi=(44) +544 200100 +fe=(75) +437 50000 +fi=(44) +544 100000 +fe=(75) +0 150050 +fi=(144) +389 300100 +fi=(44) +90 150050 +fi=(76) ++66 300100 +fi=(144) +389 300100 +fi=(76) +156 150050 +fi=(72) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs +716 300100 +fe=(75) +440 600200 +0 75025 +464 225075 +cfi=(85) +cfn=(5504) +calls=111037 211 +* 19183725 +-1 150050 ++4 375125 +cfi=(90) +cfn=(5850) +calls=111037 197 +* 8894789 +* 75025 +0 75025 +488 225075 +cfi=(85) +cfn=(5504) +calls=111037 211 +* 22204750 +-1 150050 +0 250000 +cfi=(90) +cfn=(5816) +calls=74000 63 +0 500000 +fi=(27) +2177 50000 +0 200000 +2177 100000 +fe=(75) +0 300000 +323 50000 +491 375125 +cfi=(90) +cfn=(5554) +calls=111037 314 +* 9137500 +* 75025 +-91 750250 +1011 1800450 + +fl=(32) +fn=(5508) +186 300 +493 50 ++30 50 +fi=(19) +1051 150 +fe=(32) +529 200 +cfn=(5230) ::finish_grow +calls=74 +15 +* 3550 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +189 250 + +fn=(5532) +658 300 +512 150 +fi=(10) +938 75 +fi=(47) +478 75 +0 75 +fe=(32) +523 150 +fi=(19) +1051 150 +fe=(32) +159 525 +fi=(19) +1051 225 +fe=(32) +529 300 +cfn=(5230) +calls=1118 +15 +* 6775 +fi=(27) +2177 150 ++1 75 +fe=(32) +773 75 ++1 75 +668 300 +-10 150 +fi=(10) +938 50 +fi=(47) +478 50 +0 50 +fe=(32) +523 100 +fi=(19) +1051 250 +fe=(32) +529 350 +cfn=(5230) +calls=1074 +15 +* 4375 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +668 200 + +fn=(5230) +544 2600 +fi=(10) +3212 2600 +fi=(47) +478 975 +0 325 +fe=(32) +631 325 +fi=(10) +1401 300 +fi=(23) +228 1500 +cfi=(24) +cfn=(5540) __rustc::__rust_realloc +calls=1451 41 +* 54143 +fi=(27) +965 600 +fi=(23) +298 50 ++4 25 +cfi=(6) +cfn=(5100) +calls=39 0 +* 25 +130 75 +cfi=(24) +cfn=(5102) +calls=39 -89 +* 950 +fi=(27) +965 50 ++1 975 +fe=(32) +0 650 +564 1950 +-20 600600 +fi=(10) +3212 600600 +fi=(47) +478 225225 +fe=(32) +631 150150 +fi=(10) +1401 25 +fi=(23) +228 125 +cfi=(24) +cfn=(5540) +calls=1037 41 +* 1400 +fi=(27) +965 50 +fi=(23) +298 150100 ++4 75050 +cfi=(6) +cfn=(5100) +calls=111074 0 +* 75050 +130 225150 +cfi=(24) +cfn=(5102) +calls=111074 -89 +* 3152000 +fi=(27) +965 150100 ++1 225225 +fe=(32) +0 150150 +564 450450 +-20 400 +fi=(86) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/layout.rs +75 50 ++38 50 +0 50 +fe=(32) +631 100 +fi=(23) +298 100 +128 50 +cfi=(6) +cfn=(5100) +calls=74 0 +* 50 ++2 150 +cfi=(24) +cfn=(5102) +calls=74 -89 +* 1900 +fi=(27) +965 100 ++1 150 +fe=(32) +0 100 +564 300 + +fn=(6020) >::grow_one +186 900 +493 225 ++30 225 +fi=(19) +1051 675 +fe=(32) +529 1350 +cfn=(5230) +calls=333 +15 +* 40950 +fi=(27) +2177 450 ++1 225 +fe=(32) +773 225 ++1 225 +189 900 + +fn=(5570) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5230) +calls=37 +15 +* 2075 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fn=(5662) >>::grow_one +186 300000 +493 75000 ++30 75000 +fi=(19) +1051 225000 +fe=(32) +529 450000 +cfn=(5230) +calls=111000 +15 +* 6225000 +fi=(27) +2177 150000 ++1 75000 +fe=(32) +773 75000 ++1 75000 +189 300000 + +fn=(5686) >::grow_one +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5230) +calls=37 +15 +* 20393 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fl=(26) +fn=(5684) +65 75200 +cob=(2) +cfi=(2) +cfn=(4878) +calls=112323 -65 +* 2487000 + +fl=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +fn=(5602) ::next +601 1500300 ++1 1000200 +cfn=(5604) ::next +calls=370074 1123 +* 28202100 +* 1250250 ++1 350100 ++1 450000 +fi=(91) +129 525000 +fe=(94) +777 225000 +fi=(91) +129 150000 ++4 150000 ++12 150000 +fi=(43) +1229 150000 +fi=(91) +146 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +129 375000 ++4 150000 ++12 150000 +fi=(43) +1229 75000 +fi=(91) +145 75000 ++1 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +fi=(54) +871 225000 +fe=(94) +604 375000 ++3 1250250 + +fn=(5604) +1123 1750350 ++1 750150 +955 750150 ++2 250050 +1124 250050 +fi=(44) +544 500100 +fi=(14) +1663 500100 +fi=(50) +180 250050 +fe=(94) +1125 75000 +fi=(44) +90 375000 +-90 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +0 225000 +fi=(50) +180 75000 +fe=(94) +0 75000 +fi=(50) +180 75000 +fe=(94) +1138 175050 ++1 175050 +0 75000 +fi=(50) +180 75000 +fe=(94) +1143 300000 +fi=(14) +1663 150000 +fi=(50) +180 75000 +fe=(94) +1143 450000 +0 375000 +1188 525000 +0 175050 +1261 2250450 +-73 450000 +cfn=(5658) ::check_for_duplicates +calls=111000 1036 +* 12075000 +* 150000 +fi=(14) +1663 300000 +fi=(50) +180 75000 +0 225000 +fe=(94) +1199 150000 +fi=(93) +315 75000 +0 150000 +fe=(94) +0 225000 +fi=(14) +1663 150000 +fi=(50) +180 300000 +fe=(94) +1243 75000 +fi=(149) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs +2490 75000 +fe=(94) +1243 216750 +fi=(149) +2490 216750 +fi=(14) +627 216750 +1663 433500 +fi=(50) +180 216750 +fi=(93) +0 150000 +fe=(94) +1243 75000 +0 150000 +1243 150000 +1113 150000 +0 375000 + +fn=(5658) +1036 525000 ++5 150000 +0 150000 +fi=(33) +3101 75000 +fe=(94) +1042 150000 +0 300000 +fi=(32) +611 150000 +fi=(20) +970 300000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fe=(94) +0 225000 +fi=(33) +1032 150000 ++1 75000 +cfi=(32) +cfn=(5662) +calls=111000 186 +* 8025000 +fi=(32) +611 150000 +0 225000 +fi=(18) +1963 225000 +fi=(33) +1038 225000 +fe=(94) ++16 225000 ++1 600000 + +fl=(74) +fn=(5580) ::check_root +338 200 ++1 50 ++14 25 ++1 200 + +fn=(5708) polyxml::parser::is_nil_element +151 525000 +fi=(100) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs +0 75000 +fi=(101) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +272 75000 +fe=(74) +152 1125000 +0 75000 +fi=(99) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs +403 225000 +cfi=(94) +cfn=(5602) +calls=111000 601 +* 12008500 +* 75000 +cfi=(94) +cfn=(5602) +calls=37000 601 +* 1350000 +fi=(95) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs +855 300000 +fi=(41) +-90 50000 +fi=(95) ++90 200000 ++1 100000 +fe=(74) +152 25000 +fi=(103) ++70 50000 +fi=(77) +21 50000 +fi=(76) +2635 25000 +fe=(74) +157 50000 +cfi=(103) +cfn=(5714) +calls=37000 -16 +* 950000 +fi=(77) +21 100000 +fi=(18) +847 50000 +fi=(23) +0 150000 +fe=(74) +163 75000 +cfi=(18) +cfn=(5614) +calls=111000 847 +* 2300000 ++2 675000 + +fn=(5600) polyxml::parser::namespace_scope +169 525175 ++1 75025 +fi=(100) +0 75025 +fi=(101) +272 75025 +fe=(74) +171 975325 +0 75025 +fi=(99) +403 225075 +cfi=(94) +cfn=(5602) +calls=111037 601 +* 12009850 +* 75000 +cfi=(94) +cfn=(5602) +calls=37000 601 +* 1350000 +fi=(95) +855 300075 +fi=(41) +-90 50000 +fi=(95) ++90 200050 ++1 150000 +fi=(77) +21 50000 +fi=(76) +2635 25000 +fi=(18) +847 75000 +fi=(96) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/collections/hash/map.rs +0 75025 +fe=(74) +182 75025 +cfi=(18) +cfn=(5614) +calls=111037 847 +* 2300450 ++1 75025 +fi=(41) +1162 150050 +fi=(13) +4029 75025 +fi=(59) +2434 75025 +fe=(74) +184 675225 + +fn=(5620) polyxml::parser::resolve_record_schema +215 200200 +fi=(14) +454 25025 +fe=(74) +220 50050 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) +3101 50050 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fi=(33) +3126 25025 +fe=(74) +220 25025 +fi=(13) +4029 25025 +fi=(59) +2434 25025 +fe=(74) +221 25025 +0 25025 +269 225225 + +fn=(5590) ::parse_sub_tree::<&[u8]> +405 350 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 +fi=(23) +130 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 3725 +fi=(32) +470 50 +fi=(33) +969 75 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 950 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +251 50 +fe=(74) +413 100 +cfn=(5600) +calls=37 169 +* 3000 +* 25 +fi=(33) +1196 125 +fe=(74) +415 75 +cfn=(5620) +calls=37 215 +* 1050 +fi=(27) +2177 25 +0 25 +2177 50 +fi=(41) +634 25 +fi=(33) +3101 25 +fe=(74) +33 25 ++1 100 +cfi=(98) +cfn=(5634) +calls=37 2052 +* 3225 +-7 25 ++9 75 +-4 150 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 -32 +* 1925 +* 175 +417 75 +cfn=(5638) ::parse_attributes +calls=37 967 +* 3225 +fi=(27) +2177 50 +fe=(74) +0 50 +418 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1029 25 ++3 50 +fi=(20) +-62 75 +fi=(18) +1963 75 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1038 50 +fe=(74) +420 25 ++1 25 +fi=(33) ++41 450 +3082 600000 +fi=(85) +412 800000 +cfi=(75) +cfn=(5470) +calls=296000 1006 +* 85032514 +* 100 +cfi=(75) +cfn=(5470) +calls=37 1006 +* 24575 +fe=(74) ++16 1000125 +0 200025 +428 600075 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fi=(32) +611 75000 +fi=(76) +282 150000 +fe=(74) +430 150000 +cfn=(5600) +calls=111000 169 +* 19808500 +0 150000 +fi=(33) +1029 75000 ++3 150000 ++1 50 +cfi=(32) +cfn=(5686) +calls=37 186 +* 20993 +fi=(32) +611 75000 +fi=(18) +1963 75000 +fi=(33) +1038 150000 +fe=(74) +431 150000 +fi=(18) +0 200000 +847 1200000 +fe=(74) +-73 100000 +fi=(100) +350 100000 +fi=(54) +871 50000 +fi=(33) +3126 50000 +fi=(13) +3994 100000 +fe=(74) +777 50000 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fi=(33) +0 75025 +fi=(13) +4049 75025 +fi=(59) +2868 75025 +fe=(74) +876 150050 +fi=(33) +3101 75025 ++25 75025 +fe=(74) +880 75025 +fi=(41) +634 300000 +fe=(74) +435 150000 +0 75000 +fi=(33) +3126 75000 +fe=(74) +437 75000 +fi=(76) +282 150000 +fi=(33) +1904 75000 +fi=(76) +305 150000 +fi=(32) +611 150000 +fi=(76) +305 225000 +fi=(14) +454 75000 +fi=(59) +2454 75000 +fe=(74) +440 150000 +cfn=(5694) polyxml::parser::record_content_token +calls=111000 1093 +* 1350000 +fi=(41) +634 150000 +fe=(74) +442 150000 +fi=(33) +3126 75000 +fe=(74) +446 75000 +fi=(78) +153 150000 +cfn=(5826) memchr::arch::x86_64::memchr::memchr_raw::find_avx2 +calls=73999 -75 +* 3000300 +fi=(41) +2869 100000 +fi=(11) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs +975 75025 ++1 75025 +fe=(74) +-69 225075 +fi=(41) +634 100000 +fe=(74) +792 50000 +fi=(33) +3101 75000 +fe=(74) +463 150000 +fi=(100) +0 75000 +fi=(101) +202 75000 +fi=(92) +380 150000 +fi=(101) +202 75000 +fi=(92) +384 150000 +fi=(43) +1229 25000 +fi=(91) +424 25000 +fi=(11) +975 450150 ++1 75025 +fe=(74) +-65 75025 +-1 75025 +fi=(33) +1865 50000 +fi=(76) +282 100000 +fe=(74) +0 50000 +fi=(32) +611 50000 +fi=(76) +282 50000 +fi=(14) +454 50000 +fi=(33) +1865 50000 +fi=(44) +238 100000 +fe=(74) +0 50000 +fi=(44) +238 150000 +fi=(32) +611 50000 +fi=(33) +1865 100000 +fe=(74) +914 150000 +cfn=(5880) polyxml::parser::parse_field_scalar +calls=74000 132 +* 20928803 +fi=(27) +2177 50000 +0 400000 +2177 100000 +fe=(74) +914 400000 +fi=(33) +1904 50000 +fi=(76) +305 200000 +fe=(74) +916 100000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99950 +0 50000 +fi=(20) +970 50000 +fi=(18) +573 150000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +fi=(33) +2986 150000 +fi=(91) +424 50000 +0 150000 +fi=(10) +1096 150000 +fi=(44) +90 150000 +fi=(102) +-62 150000 ++13 75000 +fi=(10) +1092 75000 +0 150000 +fi=(102) +42 650000 ++4 325000 +-5 725000 +fe=(74) +470 150000 +cfn=(5708) +calls=111000 151 +* 20683500 +0 75000 +fi=(33) +1865 75000 +fi=(76) +282 150000 +0 150000 +fi=(32) +611 75000 +fi=(76) +282 75000 +fi=(14) +454 75000 +fi=(13) +4029 75000 +fi=(59) +2434 75000 +fe=(74) +472 75000 +fi=(59) +2438 75000 +320 75000 +fi=(55) +1337 75000 +fi=(51) /rust/deps/hashbrown-0.17.1/src/map.rs +-53 75000 ++3 225000 +241 75000 +cfi=(52) +cfn=(5734) +calls=111000 694 +* 13650000 +* 75000 +fi=(106) /rust/deps/hashbrown-0.17.1/src/control/tag.rs +47 150000 +fi=(55) +2452 450000 +0 75000 +fi=(18) +573 75000 +fi=(57) +1569 225000 +fi=(104) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs +40 150000 +-40 525000 +fi=(58) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/nonzero.rs +628 75000 +fi=(55) +2032 150000 +fi=(20) +1054 300000 +fi=(77) +21 150000 +fi=(105) /rust/deps/hashbrown-0.17.1/src/lib.rs +157 225000 +cob=(2) +cfi=(2) +cfn=(5744) +calls=111000 0 +* 1473000 +* 75000 +fi=(47) +455 75000 +fe=(74) ++18 75000 +fi=(33) +1865 75000 +fi=(44) +238 150000 +fi=(32) +611 75000 +fi=(44) +238 225000 +fe=(74) +478 600000 +0 25000 +478 50000 +fi=(28) +2415 25000 +fe=(74) +488 175000 +0 25000 +488 50000 ++13 50000 +fi=(33) +3101 25025 +fe=(74) +921 50050 +fi=(33) +2877 50000 +fi=(54) +871 50000 +fi=(41) +1013 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(100) +350 50000 +fi=(103) +210 75000 +cfi=(92) +cfn=(5914) ::find:: +calls=37000 1497 +* 1200000 ++62 175000 +cfi=(41) +cfn=(5922) >::map_or::<&str, >::from::{closure#0}> +calls=37000 1222 +* 125000 +fe=(74) +0 50000 +fi=(41) +2274 50000 +fe=(74) +919 400000 +fi=(98) +1082 100000 +-17 50000 +fe=(74) +945 50 +480 100000 +fi=(98) +0 50000 +fi=(44) +245 200000 +fi=(18) +847 100000 +fe=(74) ++72 250000 +0 150000 +fi=(18) +847 250000 +cfn=(5896) +calls=74000 * +* 1000000 +* 50000 +fe=(74) +0 100000 +484 100000 +cfi=(45) +cfn=(5808) +calls=74000 13 +* 1450000 +* 200000 +fi=(41) +634 50000 +fi=(18) +847 50000 +fe=(74) +484 300000 +fi=(33) +3082 100000 +0 25000 +fe=(74) +925 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +* 75000 +cfn=(5924) ::finish +calls=37000 75 +* 27532831 +fi=(27) +2177 50000 +0 200000 +2177 50000 +fe=(74) +925 200000 +fi=(33) +1904 25000 +fi=(76) +305 50000 +fi=(32) +611 25000 +fi=(76) +305 75000 +fe=(74) +928 50000 +0 25000 +fi=(14) +454 25000 +fi=(96) +1039 100000 +cfi=(55) +cfn=(5990) , usize, std::hash::random::RandomState>>::get::<[u8]> +calls=37000 1337 +* 6550000 +fe=(74) +933 75000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +939 75000 ++1 275000 +cfn=(6000) ::push_list_item +calls=37000 62 +* 1474250 +* 25000 +fi=(33) +1865 25000 +fi=(76) +282 75000 +fe=(74) +0 25000 +fi=(32) +611 25000 +fi=(76) +282 50000 +fe=(74) +509 50000 +cfn=(5620) +calls=37000 215 +* 1050000 +fi=(27) +2177 25000 +0 25000 +2177 50000 +fe=(74) +514 50000 +cfn=(5754) ::new +calls=37000 25 +* 6950000 +0 25000 +515 100000 +cfn=(5638) +calls=37000 967 +* 28121500 +fi=(27) +2177 50000 +fe=(74) +516 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(33) +996 75000 +cfn=(5802) >::push_mut +calls=37000 +31 +* 2700000 +0 75000 +fi=(14) +454 75000 +fi=(13) +4049 75000 +fi=(59) +2868 75000 +0 125000 +fe=(74) +958 400000 +fi=(18) +847 600000 +fi=(32) +672 150 +cfn=(5532) +calls=37 -14 +* 2875 +fi=(33) +3101 25 +2981 25 +fe=(74) +958 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +fi=(18) +847 125 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 3250 +fi=(14) +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(74) +965 200 +fi=(18) +847 75 +0 25 +847 150 +fi=(33) +2877 25 +fi=(32) +611 50 +fi=(18) +1755 75 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fe=(74) +947 75 +cfn=(5924) +calls=37 75 +* 29016 +* 25 + +fn=(5638) +967 200200 ++1 25025 +fi=(100) +0 25025 +fi=(101) +272 25025 +fe=(74) +969 500500 +fi=(99) +403 75075 +cfi=(94) +cfn=(5602) +calls=37037 601 +* 9309850 +* 75000 +cfi=(94) +cfn=(5602) +calls=37000 601 +* 1350000 +fi=(95) +855 150075 +fi=(41) +-90 50000 +fi=(95) ++90 100050 ++1 125000 +fe=(74) +969 25000 +fi=(103) +222 75000 +fi=(77) +21 75000 +fi=(76) +2635 25000 +fe=(74) +0 25000 +974 50000 +cfi=(103) +cfn=(5714) +calls=37000 141 +* 950000 +0 50000 +fi=(14) +454 25000 +fi=(55) +1337 25000 +fi=(51) +-53 25000 +0 25000 +1287 25000 +241 50000 +cfi=(52) +cfn=(5734) +calls=37000 694 +* 4625000 +fi=(106) +47 75000 +fi=(55) +2452 150000 +0 25000 +fi=(18) +573 25000 +fi=(57) +1569 75000 +fi=(104) +40 50000 +-40 200000 +fi=(58) +628 25000 +fi=(55) +2032 50000 +fi=(20) +1054 75000 +fi=(77) +21 50000 +fi=(105) +157 100000 +cob=(2) +cfi=(2) +cfn=(5744) +calls=37000 0 +* 493000 +* 25000 +fi=(47) +455 25000 +fe=(74) +975 25000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +977 100000 +fi=(100) +350 50000 +fe=(74) +978 50000 +cfi=(107) +cfn=(5770) +calls=37000 236 +* 2078000 +fi=(27) +2177 25000 +0 100000 +2177 50000 +fe=(74) +0 75000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(74) +979 75000 +cfi=(108) +cfn=(5782) +calls=37000 28 +* 2617000 +fi=(27) +2177 50000 +0 200000 +2177 75000 +fe=(74) +979 225000 +fi=(98) +1082 75000 +-17 25000 +fi=(44) +245 50000 +0 25000 +fi=(98) +1082 25000 +-17 25000 +fi=(44) +245 50000 +fi=(18) +847 50000 +fe=(74) +984 225000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 50000 +fi=(11) +0 25025 +fe=(74) +994 25025 +cfi=(18) +cfn=(5614) +calls=37037 847 +* 1400450 +* 25025 +fi=(14) +454 25025 +fe=(74) +995 50050 ++3 25025 +fi=(18) +847 50050 +fe=(74) +999 225225 + +fn=(5694) +1093 525000 +fi=(14) +454 75000 +fi=(41) +634 75000 +fe=(74) +1098 75000 ++8 600000 + +fn=(5468) ::deserialize_with_limit +360 250 +fi=(75) +810 300 +fi=(33) +462 150 +0 50 +fi=(85) +412 100 +cfi=(75) +cfn=(5470) +calls=37 1006 +* 24750 +fe=(74) +-43 225 +fi=(14) ++85 25 +fi=(59) +2454 100 +fe=(74) +371 50 +cfn=(5580) +calls=37 -33 +* 475 +fi=(27) +2177 50 +fe=(74) +374 50 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/mod.rs +105 75 +fi=(151) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/lazy.rs +-46 50 +fi=(60) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cell.rs +558 50 +fi=(10) +2652 25 +fi=(11) +976 25 +fi=(59) +440 200 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 1050 +fi=(28) +251 50 +0 25 +293 200 +fi=(59) ++27 75 +fe=(74) ++52 125 +cfn=(5590) +calls=37 +33 +* 282423282 +fi=(13) +4049 25 +fi=(59) +2868 25 +0 50 +2911 25 +cfn=(6150) +calls=37 2138 +* 1725 +0 25 +fe=(74) +396 75 +fi=(18) +847 75 +0 25 +847 150 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5684) +calls=37 65 +* 3850 +fe=(74) +403 275 + +fn=(5754) +25 150000 +fi=(41) +634 25000 +fi=(33) +3101 25000 +fe=(74) +33 25000 ++1 100000 +cfi=(98) +cfn=(5634) +calls=37000 2052 +* 4175000 +-7 25000 ++9 75000 +-4 125000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 -32 +* 1925000 +* 150000 ++8 150000 + +fn=(5466) polyxml::deserialize +357 50 +cfn=(5468) +calls=37 +3 +* 282460432 + +fn=(5924) +75 225225 +fi=(14) +454 50050 +fi=(59) +2454 25025 +fi=(32) +611 25025 +fi=(33) +1865 75075 +fe=(74) +76 25025 +cfi=(45) +cfn=(5926) +calls=37037 725 +* 550550 +fi=(27) +2177 50050 +fi=(18) +0 50050 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) +180 25025 +0 125125 +180 100100 +fi=(41) +634 25000 +fe=(74) +78 25000 +fi=(50) +-78 75025 +fi=(14) +1663 150050 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +fi=(45) +4 75025 +fe=(74) ++74 75025 +fi=(98) +1082 75000 +-30 25000 +fi=(44) +238 50000 +0 25000 +fi=(98) +1082 25000 +-30 25000 ++30 75075 +-30 25025 +-15 50050 +fe=(74) +91 25025 +-91 50 +fi=(98) +1082 25 +fe=(74) +92 300 +fi=(98) +996 50 ++56 25 +-56 25 +fe=(74) +92 25 +fi=(118) +-68 125 +fe=(74) ++68 25 +fi=(98) +2493 50 +0 125 +fe=(74) +94 200 +fi=(98) +2493 50 +0 25 +2493 50 ++5 50 +1082 50 +-30 25 +fi=(54) +871 25 +fi=(18) +1755 25 +fi=(41) +2869 50 +fi=(118) +80 25 +fi=(41) +2870 50 +fi=(118) +81 25 ++1 50 +fe=(74) ++11 100 ++1 50 +fi=(98) +1082 75 +-17 25 +fi=(44) +245 50 +0 25 +fi=(98) +1082 25 +-17 25 +fi=(44) +245 50 +fi=(18) +847 50 +0 25 +847 25 +cfi=(98) +cfn=(6142) +calls=37 2483 +* 500 +0 75 +847 25 +cfi=(98) +cfn=(5984) +calls=37 2373 +* 550 +0 25 +fi=(14) +454 25 +fe=(74) +99 100 +-99 50000 +fi=(14) +454 25000 +fe=(74) +99 75000 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +0 100100 +fi=(98) +1052 125125 +fi=(14) +1663 150050 +fi=(118) +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +0 75025 +fi=(98) +1082 225075 +-30 75025 +fi=(44) +238 150050 +0 75025 +fi=(98) +1082 75025 +-30 75025 +fi=(41) +743 150050 +fi=(45) +-74 150050 +fi=(111) +0 25025 +fe=(74) +126 100100 ++1 75075 +fi=(98) +1082 25025 +1607 25025 +fe=(74) +127 25025 +fi=(98) +1615 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 +2552 50050 +-1 150150 +fi=(33) +3996 25025 +cfi=(117) +cfn=(5946) +calls=37037 32 +* 11517075 +0 25025 +fe=(74) +127 25025 +cfi=(33) +cfn=(5964) >>::into_boxed_slice +calls=37037 1723 +* 7835597 +-2 125125 ++4 50050 +0 25000 +fi=(18) +847 25000 +cfi=(98) +cfn=(5984) +calls=37000 2373 +* 550000 +* 175175 +fi=(32) +425 50050 +631 25025 +fe=(74) +129 225225 + +fn=(6000) +62 175000 +fi=(98) +1082 75000 +-30 25000 +-15 25000 +fe=(74) +63 25000 +-63 24975 +fi=(98) +1082 24975 +-17 24975 +fi=(44) +195 50000 +fi=(98) +1082 25000 +-17 25000 +fe=(74) +0 25 +63 50 +fi=(14) +454 25 +fi=(33) +3101 25 +fe=(74) +65 50 +cfi=(98) +cfn=(6004) +calls=37 1841 +* 1200 +-65 25 +fi=(98) +1082 100 +-17 50 +fe=(74) +67 25000 +fi=(44) +197 50000 +fe=(74) +68 75000 ++1 199800 +fi=(33) +1029 24975 ++3 49950 ++1 450 +cfi=(32) +cfn=(6020) +calls=333 186 +* 46350 +fi=(32) +611 24975 +fi=(20) +970 24975 +fi=(18) +1963 199800 +fi=(33) +1038 74925 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 1050 +fi=(28) +251 50 +fe=(74) +70 225 +fi=(18) +847 50 +fe=(74) +70 75 ++3 175000 + +fn=(5880) +132 100000 +fi=(76) ++5 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +146 150000 +cfi=(108) +cfn=(5782) +calls=74000 28 +* 20328803 ++1 150000 + +fl=(78) +fn=(5826) +78 50000 +fi=(84) +184 100000 +0 150000 +fi=(54) +623 100000 +fi=(84) +188 100000 ++1 100000 +fi=(88) +1161 50000 +0 50000 +fi=(84) +193 1050150 +fi=(54) +389 350050 +fi=(88) +1161 700100 +0 100000 +fe=(78) +86 100000 + +fl=(24) +fn=(6470) measured_region +79 9 +fi=(19) +2144 1 +fi=(34) +1100 1 +0 10 +fi=(26) +0 5 +fi=(152) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 4 +fi=(13) +4029 1 +fi=(59) +2434 1 +fi=(26) +0 24 +fi=(152) +491 96 +fi=(13) +4029 24 +fi=(59) +2434 24 +fe=(24) +89 125 +cfi=(74) +cfn=(5466) +calls=25 357 +* 282460482 +fi=(27) +1230 50 ++1 200 +fe=(24) +89 50 +cfi=(18) +cfn=(6416) +calls=25 847 +* 12449239 +fi=(19) +2144 25 +fi=(34) +1100 25 +fe=(24) +94 8 + +fn=(5140) +cfn=(6470) +calls=1 79 +70 294910404 + +fn=(5102) +41 125250 +fi=(13) +3994 125250 +762 125250 +fe=(24) +16 125250 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 501000 +fi=(26) +30 250500 ++1 250500 +cob=(2) +cfi=(2) +cfn=(4226) +calls=186395 -31 +* 17149778 +fe=(24) + +fn=(5540) +41 25350 +fi=(13) +3994 25350 +762 25350 +fe=(24) +33 25350 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 126750 +405 50700 +fi=(26) +70 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4458) +calls=37037 -71 +* 6884647 +-1 650 ++1 650 +cob=(2) +cfi=(2) +cfn=(4458) +calls=2488 -71 +* 50668 +fe=(24) + +fl=(38) +fn=(5182) +89 1125250 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 675150 ++12 450100 +0 1575350 +164 225050 ++1 450100 +fi=(10) +2689 450100 +3875 225050 +fi=(39) +222 225050 ++2 450100 ++17 450100 +0 225050 +241 3590050 ++1 1795025 +-1 3815100 +fe=(38) +94 900200 +-94 225050 +98 900200 + +fl=(41) +fn=(5922) +1222 25000 ++5 50000 ++4 50000 + +fl=(6) +fn=(4126) (below main) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 294910404 + +fn=(4176) +cfi=(8) +cfn=(4178) +calls=1 152 +0 294910404 + +fn=(5100) +0 125250 + +fl=(55) +fn=(5990) +1337 25000 +fi=(51) +-53 25000 +0 225000 +1287 50000 +241 50000 +cfi=(52) +cfn=(5734) +calls=37000 694 +* 4500000 +fi=(106) +47 75000 +fe=(55) +2452 200000 +0 25000 +fi=(18) +573 25000 +fi=(57) +1569 75000 +fi=(104) +40 50000 +-40 125000 +fi=(58) +628 25000 +fe=(55) +2032 50000 +fi=(20) +1054 75000 +fi=(77) +21 50000 +fi=(105) +157 100000 +cob=(2) +cfi=(2) +cfn=(5744) +calls=37000 0 +* 475000 +* 25000 +fi=(47) +455 25000 +fe=(55) +1217 250000 +fi=(51) ++76 25000 +fe=(55) + +fn=(6152) +3486 175 +2656 50 +2271 25 +3498 200 + +fl=(33) +fn=(5964) +1723 100100 +fi=(32) +616 25025 +fe=(33) +1598 75075 +fi=(32) +832 25025 +fi=(10) +1401 25025 +fi=(32) +839 50050 +fi=(10) +1401 25025 +fi=(23) +228 75075 +cfi=(24) +cfn=(5540) +calls=37037 41 +* 7260022 +fi=(27) +965 50050 +fe=(33) +1731 125125 + +fn=(5802) +1027 125000 ++2 25000 ++3 50000 +fi=(20) +-62 50000 +fi=(18) +1963 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fe=(33) +1038 50000 ++4 100000 + +fl=(53) +fn=(5292) +256 250000 ++2 250000 ++4 750000 +0 500000 +278 250000 ++1 750000 ++3 500000 +0 625000 +fi=(18) +573 125000 +fe=(53) +288 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fe=(53) +78 125000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 250000 +fe=(53) +78 125000 +290 125000 ++2 125000 +-10 250000 +0 500000 +126 500000 +fi=(18) +573 200000 +fe=(53) +132 400000 +0 300000 +132 450000 +fi=(54) +871 25000 +fi=(18) +573 25000 +fe=(53) +134 75000 ++1 25000 ++2 500000 ++2 150000 +298 25000 +0 25000 +300 50000 +-2 225000 +0 225000 +300 450000 + +fl=(92) +fn=(5914) +1497 275000 +fi=(10) +1096 50000 +fi=(44) +90 25000 +fi=(102) +-62 50000 ++13 50000 +-41 50000 +42 200000 ++4 100000 +-5 225000 +fe=(92) +1499 175000 + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4126) +calls=1 0 +0 294910404 + +totals: 294910404 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-annotated.txt new file mode 100644 index 0000000..d583c4d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-annotated.txt @@ -0,0 +1,101 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/control/write-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 32437241 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics write 1000 25 instructions (PID 328692, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +88,873,605 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +7,250,000 ( 8.16%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +7,202,000 ( 8.10%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +6,239,550 ( 7.02%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +6,077,100 ( 6.84%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs: as core::io::cursor::WriteThroughCursor>::write_all [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +5,226,325 ( 5.88%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs:>>>::write_event:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +2,962,775 ( 3.33%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,725,825 ( 3.07%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs:>>>::write_event:: +2,500,200 ( 2.81%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +2,240,625 ( 2.52%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs:::format_scalar_to +2,100,350 ( 2.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +2,050,200 ( 2.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> +2,000,000 ( 2.25%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::format_scalar_to [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +1,925,000 ( 2.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 +1,825,575 ( 2.05%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::validate_lexical_list_items [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +1,575,375 ( 1.77%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>>>::write_event:: +1,433,475 ( 1.61%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs:::format_scalar_to +1,250,000 ( 1.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 +1,200,400 ( 1.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/io/cursor.rs:>>>::write_event:: +1,187,750 ( 1.34%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] +1,150,000 ( 1.29%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::validate_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +1,100,400 ( 1.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:>>>::write_event:: +1,079,375 ( 1.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>::reserve::do_reserve_and_handle:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] +1,062,650 ( 1.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 975,000 ( 1.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 916,750 ( 1.03%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 900,375 ( 1.01%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::io::cursor::WriteThroughCursor>::write_all + 877,975 ( 0.99%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 825,925 ( 0.93%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 775,225 ( 0.87%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>>>::write_event:: + 651,125 ( 0.73%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 600,150 ( 0.68%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs:>>>::write_event:: + 600,000 ( 0.68%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 550,250 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>>::write_event:: + 525,000 ( 0.59%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::validate_lexical_list_items'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 500,000 ( 0.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attribute::<(&str, &str)> + 475,825 ( 0.54%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>>::write_event:: + 466,750 ( 0.53%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 451,575 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 450,450 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 450,225 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 450,150 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 450,000 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attribute::<(&str, &str)> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 450,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 425,425 ( 0.48%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs:::matches_variant [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 425,000 ( 0.48%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attr [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 402,475 ( 0.45%) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs:::write_model::<&mut core::io::cursor::Cursor>> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 400,000 ( 0.45%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 400,000 ( 0.45%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::push_attr + 375,000 ( 0.42%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 351,225 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs:__rustc::__rust_realloc + 350,000 ( 0.39%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attr + 350,000 ( 0.39%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 325,025 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:>>>::write_event:: + 314,000 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 300,000 ( 0.34%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:>::from [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics] + 300,000 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 280,300 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::format_scalar_to + 262,500 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs:::format_scalar_to + 250,875 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 250,875 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:>::reserve::do_reserve_and_handle:: + 250,875 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 225,975 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 225,225 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:::matches_variant + 225,075 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs: as core::io::cursor::WriteThroughCursor>::write_all + 225,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::push_attr + 224,825 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs:::format_scalar_to + 200,700 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_realloc + 200,000 ( 0.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 200,000 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attribute::<(&str, &str)> + 200,000 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 192,225 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::format_scalar_to + 175,700 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 168,725 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:::format_scalar_to + 150,525 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::reserve::do_reserve_and_handle:: + 150,050 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>>>::write_event:: + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-valgrind.txt new file mode 100644 index 0000000..888b4ff --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-valgrind.txt @@ -0,0 +1,12 @@ +==328692== Callgrind, a call-graph generating cache profiler +==328692== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==328692== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==328692== Command: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics write 1000 25 instructions +==328692== Parent PID: 328685 +==328692== +==328692== For interactive control, run 'callgrind_control -h'. +==328692== +==328692== Events : Ir +==328692== Collected : 88873605 +==328692== +==328692== I refs: 88,873,605 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000.callgrind new file mode 100644 index 0000000..e3e75dd --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/control/write-1000.callgrind @@ -0,0 +1,2016 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 328692 +cmd: benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics write 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 32437241 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 88873605 + + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4126) (below main) +calls=1 0 +0 88873605 + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4128) (below main) +cfn=(4162) 0x000000000002a580 +calls=1 0 +0 88873605 + +fn=(4508) 0x00000000000b20e0 +0 18350 +cfn=(4952) 0x00000000000b0f70 +calls=721 0 +0 3050 +0 1125 + +fn=(4976) 0x0000000000198400 +0 103400 + +fn=(4488) 0x0000000000197a00 +0 7202000 + +fn=(4952) +0 8275 + +fn=(4232) 0x00000000000b2400 +0 20825 +cfn=(4952) +calls=36 0 +0 775 +0 15950 +cfn=(4952) +calls=749 0 +0 2800 +0 2075 + +fn=(4878) free +0 300 +cfn=(4508) +calls=4021 0 +0 3175 +0 825625 + +fn=(4226) malloc +0 400 +cfn=(4232) +calls=4089 0 +0 10525 +0 650725 + +fn=(4460) 0x00000000000b4180 +0 1182900 +cfn=(4232) +calls=163 0 +0 31900 +0 1675 +cfn=(4502) 0x00000000000b2300 +calls=2112 0 +0 8425 +0 1050 +cfn=(4952) +calls=109 0 +0 1650 +0 1325 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=162 0 +0 620850 +0 600 +cfn=(4502) +calls=162 0 +0 13900 +0 200 + +fn=(4162) +cob=(6) +cfi=(6) +cfn=(4176) main +calls=1 0 +0 88873605 + +fn=(4458) realloc +0 2685850 +cfn=(4460) +calls=38275 0 +0 1864475 +0 276925 + +fn=(4502) +0 2100 +cfn=(4508) +calls=2274 0 +0 19350 +0 875 + +ob=(3) +fl=(3) +fn=(4486) +0 200 +cob=(2) +cfi=(2) +cfn=(4488) +calls=209 0 +0 620650 + +ob=(6) +fl=(123) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs +fn=(6240) >>>::write_event:: +262 1600400 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs +792 600150 +fe=(123) +264 600150 ++1 375125 ++53 75025 +0 75025 +318 75025 +-31 250000 ++26 50000 +fi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +616 50000 +fi=(124) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs +199 50000 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +2496 200000 +fi=(124) +136 100000 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +3101 75 +fi=(124) +146 75 +fi=(10) +2689 75 +fi=(32) +764 75 +-94 75 +0 50000 +fi=(33) +3101 50000 +fi=(124) +151 150000 +fe=(123) +272 375125 +fi=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +765 225075 +fi=(124) +205 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 50000 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +664 250000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=72000 0 +* 705300 +fi=(124) +206 100000 +fi=(33) +2224 50000 +fi=(124) +212 100000 +fi=(18) +847 150000 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +0 150000 +fi=(18) +847 50000 +fe=(123) +0 75025 +318 75025 +fi=(32) +616 75025 +fi=(124) +199 75025 +fi=(10) +2496 300100 +fi=(124) +136 150050 +fi=(32) +0 75025 +fi=(33) +3101 75025 +fi=(124) +151 225075 ++54 75025 +fi=(18) +664 75025 +fi=(124) +206 150050 +fi=(33) +2224 75025 +fi=(124) +212 75025 +fi=(121) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/io/cursor.rs +508 300100 +cfi=(124) +cfn=(6248) as core::io::cursor::WriteThroughCursor>::write_all +calls=108036 315 +* 3891925 +0 75025 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +2177 150050 +fi=(121) +508 300100 +cfi=(124) +cfn=(6248) +calls=108036 315 +* 3976325 +0 75025 +fi=(41) +765 150050 +fi=(18) ++82 300100 +fi=(23) +175 100000 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5684) __rustc::__rust_dealloc +calls=36000 65 +* 850000 +0 75025 +fi=(18) +847 75025 +fi=(41) +-82 400100 +fe=(123) +308 1600400 +fi=(32) +616 75025 +fi=(124) +199 75025 +fi=(10) +2496 300100 +fi=(124) +136 150050 +fi=(33) +3101 25 +fi=(124) +146 25 +fi=(10) +2689 25 +fi=(32) +764 25 +-94 25 +fi=(33) +3101 75025 +fi=(124) +151 225075 ++54 75025 +fi=(18) +664 75025 +fi=(124) +206 150050 +fi=(33) +2224 150050 +fi=(124) +212 75025 +fi=(10) +2496 300100 +fi=(32) +616 75025 +fi=(124) +136 150050 +fi=(32) +0 75025 +fi=(124) +151 225075 +fi=(32) +672 300 +cfn=(5532) >::reserve::do_reserve_and_handle:: +calls=108 -14 +* 660025 +* 175 +cfn=(5532) +calls=36 -14 +* 18650 +* 25 +fi=(124) +205 75025 +fi=(20) +970 75025 +fi=(18) +664 300100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=108036 0 +* 1125375 +fi=(124) +206 150050 +fi=(33) +2224 75025 +fi=(124) +212 75025 +fi=(121) +508 300100 +cfi=(124) +cfn=(6248) +calls=108036 315 +* 3976325 +0 150050 +fi=(18) +847 300100 +fe=(123) + +fl=(6) +fn=(4126) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 88873605 + +fn=(4176) +cfi=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +cfn=(4178) std::rt::lang_start_internal +calls=1 152 +0 88873605 + +fn=(5100) __rustc::__rust_no_alloc_shim_is_unstable_v2 +0 25025 + +fl=(101) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +fn=(6278) ::push_attribute::<(&str, &str)> +256 175000 +fi=(100) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs ++28 75000 +fi=(32) +611 25000 +fi=(128) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/char/methods.rs +2558 25000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1440 25000 +fi=(33) +2224 75000 +fi=(144) +781 50000 +cfi=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +cfn=(6290) >::from +calls=36000 376 +* 2097500 +fe=(101) +261 75000 +cfn=(6300) ::push_attr +calls=36000 +41 +* 5899500 ++1 200000 +fi=(100) ++23 50000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +478 25000 +fi=(32) +0 25000 +461 25000 +0 100000 +cfi=(6) +cfn=(5100) +calls=36000 0 +0 25000 +0 25000 +fi=(23) +130 75000 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/control/src/main.rs +cfn=(5102) __rustc::__rust_alloc +calls=36000 -89 +* 950000 +fi=(32) +470 50000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +0 25000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 375000 +* 50000 +fi=(100) +286 75000 +fi=(32) +672 175000 +cfn=(5532) +calls=36000 -14 +* 5375000 +* 75000 +fe=(101) + +fn=(6300) +302 225000 +fi=(100) +-18 75000 +fi=(33) +1461 50000 +fi=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +222 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +0 25000 +fi=(20) +970 25000 +fi=(18) +573 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 450000 +fi=(33) +2986 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +-59 25000 +fi=(18) +-38 25000 +fi=(33) +2986 50000 +fi=(100) +0 75000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +fi=(20) +970 50000 +fi=(18) +573 50000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 449500 +fi=(33) +2986 50000 +fi=(32) +764 25000 +-94 25000 +fi=(128) +2558 25000 +fi=(40) +1440 25000 +fi=(33) +2224 25000 +fi=(18) +847 75000 +fe=(101) +309 200000 +fi=(32) +672 100000 +cfn=(5532) +calls=36000 -14 +* 3125000 +-56 25000 +fi=(33) +3101 50000 +fe=(101) + +fl=(8) +fn=(4178) +fi=(145) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5136) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 88873605 +fe=(8) + +fn=(5136) +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5138) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 88873605 + +fl=(111) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/lib.rs +fn=(6164) polyxml::serialize +39 50 +fi=(120) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/serializer.rs +181 125 +cfn=(6166) ::serialize_with_options +calls=36 +3 +* 88868600 +* 25 +fe=(111) +46 75 + +fl=(120) +fn=(6166) +184 350 +cfi=(6) +cfn=(5100) +calls=36 0 +* 25 +fi=(23) +-54 75 +cfi=(24) +cfn=(5102) +calls=36 -89 +* 11950 +fi=(32) +470 50 +fi=(121) +102 100 +fe=(120) ++91 50 +fi=(41) +0 25 +743 25 +0 25 +fi=(123) +124 75 +fe=(120) ++74 50 +0 50 +200 75 +cfn=(6176) ::build +calls=36 23 +* 7000 +fi=(41) +743 75 +0 25 +743 75 +0 50 +fe=(120) +203 225 +cfn=(6204) ::write_model::<&mut core::io::cursor::Cursor>> +calls=36 +82 +* 88847675 +* 25 +fi=(27) +2177 50 +fe=(120) +213 125 +fi=(18) +847 125 +fe=(120) +214 225 + +fn=(6222) ::validate_lexical_list_items +243 600200 ++1 525100 ++16 75 +fi=(33) +1865 25 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +1663 25 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 25 +0 125 +fe=(120) +262 100 +cfn=(6223) ::validate_lexical_list_items'2 +calls=36 -19 +* 525 +* 99900 +cfn=(6223) +calls=35964 -19 +* 524475 +fi=(27) +2177 50000 +fi=(14) +627 25000 +1663 25000 +fi=(50) +180 25000 +fe=(120) ++85 75025 ++1 525175 + +fn=(6223) +243 200000 ++1 100000 ++16 25000 ++5 25000 ++1 175000 + +fn=(6316) ::validate_scalar +268 200000 ++10 50000 +-9 150000 ++9 200000 +-9 350000 ++13 50000 ++1 150000 + +fn=(6176) +23 250 +fi=(33) +462 100 +fe=(120) +28 50 +cfn=(6178) ::collect_namespaces +calls=36 +60 +* 6150 +fi=(33) +3126 25 +fe=(120) +30 25 +fi=(41) +709 50 +fe=(120) +0 25 +31 25 +fi=(32) +425 50 +631 25 +fe=(120) +86 225 + +fn=(6204) +285 250 ++9 125 +0 50 +307 75 +0 25 +fi=(14) +454 25 +fi=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2454 75 +fe=(120) +308 75 +cfi=(45) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/schema.rs +cfn=(6206) ::matches_variant +calls=36 182 +* 950 +* 50 +fi=(50) +0 50 +fi=(33) +1865 25 +fi=(14) +1663 50 +fi=(50) +180 25 +0 450 +fi=(32) +611 25 +fi=(33) +1865 50 +fe=(120) +328 50 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +184 50 ++2 50 +fi=(41) +743 25 +0 50 +fi=(45) +669 50 +fe=(120) +338 100 +cfn=(6222) +calls=36 -95 +* 750775 +fi=(27) +2177 75 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +fi=(41) +634 50 +fe=(120) +342 25 +fi=(23) +0 75 +fe=(120) +390 25 +cfi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +cfn=(5182) core::str::converts::from_utf8 +calls=36 89 +* 2600 +fi=(27) +0 50 +2177 50 +fi=(111) +0 25 +fe=(120) +391 50 ++3 75 +fi=(101) +124 100 +0 25 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 500 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +415 125 ++33 50 ++21 200 +cfi=(123) +cfn=(6240) +calls=36 262 +* 4400 +* 25 +0 25 +fi=(27) +965 50 +fi=(111) +0 25 +fe=(120) +473 50 ++30 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 475 +fe=(120) +597 125 +328 50 +fi=(44) +184 50 ++2 50 +fi=(41) +743 50 +0 50 +fi=(131) /home/bailey/github/polyxml-perf-control/crates/polyxml-core/src/value.rs +59 25 +fe=(120) +599 25 +fi=(41) +743 75 +fi=(27) +0 25 +fi=(41) +743 50 +fe=(120) +605 225 +0 25 +637 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25075 +fi=(14) +1663 25000 +fi=(50) +180 25000 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +2415 25000 +fe=(120) +639 175000 +fi=(41) +743 50000 +fi=(14) +454 25000 +fi=(41) +743 50000 +fi=(23) +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fi=(59) +2454 25000 +fe=(120) +695 200000 +cfn=(6205) ::write_model::<&mut core::io::cursor::Cursor>>'2 +calls=36000 285 +* 87303975 +* 25000 +fi=(27) +2177 50000 +fe=(120) +0 25 +fi=(41) +743 25 +fi=(118) +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +fi=(100) +350 50 +fe=(120) +737 175 +cfi=(123) +cfn=(6240) +calls=36 262 +* 3800 +fi=(27) +965 50 +fe=(120) +741 200 +0 25 +740 25 ++1 25 +fi=(18) +847 50 +fi=(23) +0 25 +fi=(18) +847 75 +fe=(120) + +fn=(6205) +285 250000 ++9 125000 +0 50000 +307 75000 +0 25000 +fi=(14) +454 25000 +fi=(59) +2454 75000 +fe=(120) +308 75000 +cfi=(45) +cfn=(6206) +calls=36000 182 +* 950000 +* 50000 +fi=(50) +0 50000 +fi=(33) +1865 25000 +fi=(14) +1663 50000 +fi=(50) +180 25000 +0 450000 +fi=(32) +611 75000 +fi=(33) +1865 150000 +fe=(120) +328 150000 +fi=(44) +184 150000 ++2 150000 +fi=(41) +743 75000 +0 150000 +fi=(45) +669 150000 +fe=(120) +338 300000 +cfn=(6222) +calls=108000 -95 +* 1725000 +fi=(27) +2177 225000 +fi=(118) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fi=(41) +634 50000 +fe=(120) +342 25000 +fi=(23) +0 75000 +fe=(120) +390 25000 +cfi=(38) +cfn=(5182) +calls=36000 89 +* 1475000 +fi=(27) +0 50000 +2177 50000 +fi=(111) +0 25000 +fe=(120) +391 50000 ++3 75000 +fi=(101) +124 100000 +0 25000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 550000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 100000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +fe=(120) +415 375000 +0 25000 +328 50000 +fi=(44) +184 50000 ++2 50000 +fi=(41) +743 50000 +0 50000 +fi=(131) +59 25000 +fe=(120) +417 25000 +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(120) +418 50000 +cfi=(38) +cfn=(5182) +calls=36000 89 +* 1225000 +fi=(27) +0 50000 +2177 50000 +0 25000 +fe=(120) +391 25000 ++28 25000 ++3 75000 +-3 25000 +0 25000 +424 100000 ++1 100000 +cfn=(6266) ::format_scalar_to +calls=36000 216 +* 2805750 +* 125000 +278 25000 +-9 100000 +426 50000 +278 150000 +-9 75000 +fi=(100) ++81 25000 +fe=(120) ++77 175000 +cfi=(101) +cfn=(6278) +calls=36000 256 +* 16322000 +fi=(18) +847 125000 +fe=(120) +269 125000 +448 50000 ++21 200000 +cfi=(123) +cfn=(6240) +calls=36000 262 +* 5319400 +* 25000 +0 25000 +fi=(27) +965 50000 +fi=(111) +0 25000 +fe=(120) +473 50000 ++30 50000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 475000 +fe=(120) +597 375000 +328 100000 +fi=(44) +184 100000 ++2 100000 +fi=(41) +743 100000 +0 100000 +fi=(131) +59 50000 +fe=(120) +599 50000 +fi=(41) +743 150000 +fi=(27) +0 50000 +fi=(41) +743 100000 +fe=(120) +605 450000 +fi=(41) +0 100000 +fe=(120) +607 200000 ++1 200000 +cfn=(6266) +calls=72000 216 +* 8087575 +* 150000 +0 100000 +608 100000 +fi=(32) ++3 50000 +fi=(33) +1865 50000 +fe=(120) +609 250000 +cfn=(6316) +calls=72000 268 +* 1150000 +fi=(27) +2177 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(120) +610 100000 +cfi=(38) +cfn=(5182) +calls=72000 89 +* 3075000 +fi=(27) +0 100000 +2177 100000 +0 50000 +fe=(120) +391 50000 +611 50000 +0 50000 +fi=(41) +743 50000 +fi=(33) +0 50000 +fe=(120) +614 150000 ++4 400000 +cfi=(123) +cfn=(6240) +calls=72000 262 +* 8821225 +fi=(27) +965 100000 +fi=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +108 200000 +cfn=(6320) quick_xml::escape::_escape::::{closure#0}, &str> +calls=72000 +93 +* 5613050 +fi=(101) +564 250000 +fe=(120) ++61 200000 +cfi=(123) +cfn=(6240) +calls=72000 262 +* 4466075 +fi=(27) +965 100000 +fe=(120) +630 350000 +cfi=(123) +cfn=(6240) +calls=72000 262 +* 7618900 +fi=(27) +965 100000 +fe=(120) +634 50000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 100000 +fi=(118) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fi=(100) +350 50000 +fe=(120) +737 175000 +cfi=(123) +cfn=(6240) +calls=36000 262 +* 3800000 +fi=(27) +965 50000 +fe=(120) +741 200000 +0 25000 +740 25000 ++1 25000 +fi=(18) +847 50000 +fi=(23) +0 25000 +fi=(18) +847 75000 +fe=(120) + +fn=(6266) +216 600000 ++4 300000 +0 75000 +220 225000 ++7 25000 +fi=(146) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/f64.rs +1264 25000 +886 100000 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +1037 50000 +fi=(32) +611 50000 +fe=(120) +223 25000 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2144 25000 +fi=(147) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/api.rs +50 25000 +fi=(125) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs +310 50000 ++2 50000 +118 22500 ++2 45000 ++1 45000 +fi=(126) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +-60 22500 +fi=(125) ++16 22500 +-39 45000 ++76 67500 +fi=(44) +219 22500 +fi=(125) +68 22500 ++20 22500 ++1 22500 +-21 22500 ++21 45000 +314 22500 +0 125000 +fi=(130) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/bit.rs +178 50000 +fi=(19) +2105 25000 +fi=(127) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs +121 25000 +fi=(10) +0 25000 +fi=(129) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs +292 50025 +0 50 +fi=(130) +282 50 +fi=(10) +154 25 +fi=(148) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/decimal.rs +32 50 +fi=(44) +186 25 +fi=(19) +2150 25 +fi=(148) +108 25 +fi=(129) +-54 25 +fi=(149) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs +181 100 +fi=(130) +282 49950 +fi=(10) +154 24975 +fi=(148) +32 49950 +fi=(44) +186 24975 +fi=(19) +2150 24975 +fi=(148) +108 24975 +fi=(129) +-54 24975 +fi=(149) +181 99900 +fi=(125) +0 25000 +fi=(149) +186 50000 +fi=(129) +53 50000 +fi=(125) +310 50000 ++2 24500 +118 9375 ++2 18750 ++1 28125 +fi=(126) +-60 3350 +fi=(125) ++16 3350 +-39 6700 ++76 10050 +fi=(44) +219 3350 +fi=(125) +68 3350 ++20 3350 ++1 3350 +-21 3350 ++21 6700 +fi=(129) +225 3350 ++3 9500 +fi=(44) +0 99900 +fi=(129) +352 24975 +0 49950 +fi=(130) +178 24975 +fi=(115) +1057 74925 +fi=(19) +2105 24975 +fi=(115) +1057 99900 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 24975 +fi=(129) +875 24975 +456 49950 +fi=(44) +219 24975 +fi=(150) +2261 24975 +fi=(44) +219 49950 +fi=(151) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/index.rs +13 24975 +fi=(129) +883 24975 +457 24975 +1381 149850 +fi=(151) +13 24975 +fi=(129) +461 49950 ++12 74925 +836 99900 +-6 74925 ++7 49950 +-7 99900 +968 24975 +fi=(10) +2728 24975 +fi=(129) +484 24975 ++13 49950 +-51 49950 ++54 24975 +fi=(125) +314 5000 +fi=(44) +-95 2250 +fi=(125) +68 2250 ++20 4500 +fi=(23) +-88 12750 +fi=(125) +319 38250 ++2 25500 +fi=(126) +61 250 +fi=(125) ++16 500 +314 250 +0 4500 +314 8625 +fi=(44) +-95 2350 +fi=(125) +68 4700 ++20 2350 ++1 4700 +fi=(129) +225 2350 ++3 7000 +fi=(44) +-9 6025 +fi=(125) +68 12050 ++20 6025 ++1 6025 +-51 12050 ++76 18075 +-46 6025 ++20 6025 ++1 6025 +-21 6025 ++21 12050 +fi=(129) +225 6025 ++3 12675 +fi=(125) ++98 25500 +fi=(126) +61 525 +fi=(125) ++16 525 +fi=(129) +225 1575 +0 24975 +1398 74925 +535 24975 +1404 149850 ++2 99900 +0 24975 +fi=(10) +2728 24975 +fi=(129) +1088 24975 +1412 74925 +0 36050 +fi=(10) +2728 36050 +fi=(129) +1088 36050 +1412 108150 +fi=(10) +2728 24975 +fi=(129) +1088 24975 +1421 124875 +-32 49950 +fi=(125) +328 38250 +118 12750 ++2 25500 ++1 25500 +fi=(126) +-60 10250 +fi=(125) ++16 10250 +-39 30750 ++76 30750 +fi=(44) +219 10250 +fi=(125) +68 10250 ++20 10250 ++1 10250 +-21 10250 ++21 10250 +-51 10250 ++76 30750 +-46 10250 ++20 10250 ++1 10250 +-21 10250 ++21 20500 +fi=(129) +225 10250 ++3 20500 ++19 37500 +fi=(44) +102 18750 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1142 37500 +0 18750 +1142 18750 +fi=(19) +2144 18750 +0 18750 +2144 18750 +fi=(129) +251 56250 +fi=(34) +1142 18750 +fi=(19) +2144 12500 +fi=(129) +251 37500 +fi=(34) +1142 12500 +fi=(129) +248 18750 ++7 18750 +fi=(127) +154 18750 +fi=(10) +1092 18750 +fi=(44) +219 2500 +fi=(125) +68 5000 ++20 2500 ++1 2500 +-51 7500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 2500 +-51 2500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 5000 +fi=(129) +225 2500 ++3 5000 +fi=(10) +1096 12500 +fi=(44) +102 12500 +fi=(152) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/specialize.rs +-68 18750 +cob=(2) +cfi=(2) +cfn=(4976) +calls=9000 -34 +* 103400 +fi=(129) +236 6250 ++3 6250 +fi=(127) +-85 12500 +0 31250 +cfi=(38) +cfn=(5182) +calls=9000 89 +0 403500 +0 175000 +cfi=(38) +cfn=(5182) +calls=63000 89 +0 2609250 +fi=(27) +714 100000 ++1 50000 +fe=(120) +0 100000 +241 400000 +0 50000 +241 200000 + +fn=(6178) +88 225 ++1 100 +fi=(33) +-89 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fi=(14) +454 25 +fi=(59) +2454 50 +fe=(120) +0 25 +cfn=(6179) ::collect_namespaces'2 +calls=36 88 +0 3225 +0 25 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +-85 50 ++5 225 +fi=(28) +2415 25 +fe=(120) +103 75 +fi=(14) +454 25 +fe=(120) +103 25 +0 25 +110 50 +0 50 +126 25 +cfi=(45) +cfn=(6188) ::variants +calls=36 +17 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +127 25 +fi=(32) +425 50 +631 25 +fe=(120) +135 200 + +fn=(6179) +88 225 ++1 100 +fi=(33) +-89 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fe=(120) +0 75 +fi=(14) +1663 75 +fi=(50) +180 75 +fe=(120) +-85 150 ++5 525 +0 25 +110 50 +0 50 +126 25 +cfi=(45) +cfn=(6188) +calls=36 +17 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +127 25 +fi=(32) +425 50 +631 25 +fe=(120) +135 200 + +fl=(45) +fn=(6188) +143 350 +fi=(14) +454 50 +fi=(59) +2454 50 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 50 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 100 ++45 50 +fi=(13) +4149 50 +fi=(97) +97 50 +fi=(13) +3994 50 +fi=(33) +1865 50 +fi=(10) +3212 350 +fi=(47) +478 100 +fi=(32) +-17 100 +fi=(122) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/take.rs +0 50 +fi=(36) +440 200 +fi=(13) +4049 50 +fi=(97) +111 50 ++7 200 +fe=(45) ++30 450 + +fn=(6206) +182 200200 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(97) +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) +180 25025 +0 75075 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fe=(45) ++73 225225 + +fl=(30) +fn=(5138) +fi=(145) +cfi=(24) +cfn=(5140) xml_diagnostics::main +calls=1 43 +250 88873605 +fe=(30) + +fl=(107) +fn=(6292) quick_xml::escape::_escape::::{closure#0}, &str> +201 225000 ++3 50000 +fi=(20) +970 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 225000 +fi=(14) +1663 144500 +fi=(50) +385 72250 +fi=(14) +1663 144500 +fi=(50) +379 144500 +fe=(107) +169 72250 +0 144500 +218 75000 ++7 125000 ++2 225000 + +fn=(6320) +201 500000 ++3 50000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +0 250000 +180 250000 +0 150000 +fi=(14) +1663 675100 +fi=(50) +385 337550 +fi=(14) +1663 337550 +fi=(50) +180 337550 +379 675100 +fe=(107) +109 337550 +0 712650 +218 250000 ++7 200000 ++2 450000 + +fl=(124) +fn=(6248) +315 1800600 +fi=(32) +616 225075 +fe=(124) +199 225075 +fi=(10) +2496 900300 +fe=(124) +136 450150 +fi=(33) +3101 75 +fe=(124) +146 75 +fi=(10) +2689 75 +fi=(32) +764 75 +-94 75 +fi=(33) +3101 225000 +fe=(124) +151 675000 +fi=(32) +672 600 +cfn=(5532) +calls=108 -14 +* 39500 +* 150 +fi=(33) +3101 75 +fe=(124) +151 225 ++54 225075 +fi=(20) +970 225075 +fi=(18) +664 450150 +cob=(2) +cfi=(2) +cfn=(4488) +calls=324108 0 +* 3476175 +fe=(124) +206 450150 +fi=(33) +2224 225075 +fe=(124) +212 225075 +319 2025675 + +fl=(32) +fn=(5532) +658 100700 +512 50350 +fi=(10) +938 25175 +fi=(47) +478 25175 +0 25175 +fe=(32) +523 50350 +fi=(19) +1051 50350 +fe=(32) +159 176225 +fi=(19) +1051 75525 +fe=(32) +529 100700 +cfn=(5230) ::finish_grow +calls=36258 +15 +* 5186875 +fi=(27) +2177 50350 ++1 25175 +fe=(32) +773 25175 ++1 25175 +668 100700 +-10 75000 +fi=(10) +938 25000 +fi=(47) +478 25000 +0 25000 +fe=(32) +523 50000 +fi=(19) +1051 125000 +fe=(32) +529 175000 +cfn=(5230) +calls=36004 +15 +* 2400000 +fi=(27) +2177 50000 ++1 25000 +fe=(32) +773 25000 ++1 25000 +668 100000 + +fn=(5230) +544 201400 +fi=(10) +3212 201400 +fi=(47) +478 75525 +0 25175 +fe=(32) +631 25175 +fi=(10) +1401 25175 +fi=(23) +228 125875 +cfi=(24) +cfn=(5540) __rustc::__rust_realloc +calls=36276 41 +* 4179875 +fi=(27) +965 50350 ++1 75525 +fe=(32) +0 50350 +564 151050 +-20 200000 +fi=(10) +3212 200000 +fi=(47) +478 75000 +fe=(32) +631 50000 +fi=(10) +1401 25000 +fi=(23) +228 125000 +cfi=(24) +cfn=(5540) +calls=36002 41 +* 1400000 +fi=(27) +965 50000 ++1 75000 +fe=(32) +0 50000 +564 150000 + +fl=(26) +fn=(5684) +65 25000 +cob=(2) +cfi=(2) +cfn=(4878) +calls=42043 -65 +* 825000 + +fl=(94) +fn=(6290) +376 75000 ++2 50000 ++1 50000 +fi=(107) +168 50000 +cfn=(6292) +calls=36000 +33 +* 1722500 +* 25000 +fe=(94) +377 25000 ++4 100000 + +fl=(24) +fn=(5102) +41 25025 +fi=(13) +3994 25025 +762 25025 +fe=(24) +16 25025 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 100100 +fi=(26) +30 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4226) +calls=46080 -31 +* 661650 +fe=(24) + +fn=(5540) +41 50175 +fi=(13) +3994 50175 +762 50175 +fe=(24) +33 50175 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 250875 +405 100350 +fi=(26) +70 100350 ++1 100350 +cob=(2) +cfi=(2) +cfn=(4458) +calls=72278 -71 +* 4827250 +fe=(24) + +fn=(6446) measured_region +79 9 +fi=(19) +2144 1 +fi=(34) +1100 1 +0 8 +fi=(26) +0 3 +fi=(19) +2144 25 +fi=(34) +1100 25 +fi=(133) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 50 +fe=(24) +91 175 +cfi=(111) +cfn=(6164) +calls=25 -52 +* 88868875 +fi=(27) +1230 50 ++1 100 +fi=(133) +491 50 +fi=(32) +631 50 +425 25 +fi=(26) +65 25 +cob=(2) +cfi=(2) +cfn=(4878) +calls=25 -65 +* 4100 +* 25 +fe=(24) ++29 8 + +fn=(5140) +cfn=(6446) +calls=1 79 +70 88873605 + +fl=(38) +fn=(5182) +89 750125 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 450075 ++12 300050 +0 1050175 +145 250 ++19 150150 ++1 300300 +fi=(10) +2689 300300 +3875 150150 +fi=(39) +222 150150 ++23 250 +-21 300050 ++17 300050 +0 150025 +241 1175200 ++1 587600 +-1 1325225 +fe=(38) +94 600100 +-94 150025 +98 600100 + +totals: 88873605 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-Cargo.toml b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-Cargo.toml new file mode 100644 index 0000000..7afbad6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-Cargo.toml @@ -0,0 +1,9 @@ +[package] +name="xml-diagnostics" +version="0.0.0" +edition="2021" +[workspace] +[dependencies] +polyxml={path="/home/bailey/github/PolyXML/crates/polyxml-core"} +[profile.release] +debug=1 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-allocations.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-allocations.txt new file mode 100644 index 0000000..cae34e6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-allocations.txt @@ -0,0 +1,12 @@ +memcap: <=7798 MiB (60% of 12996 MiB available) [systemd MemoryMax, swap off] +operation=read,count=0,iterations=1,allocations=12,reallocations=5,requested_bytes=11093,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7811 MiB (60% of 13019 MiB available) [systemd MemoryMax, swap off] +operation=write,count=0,iterations=1,allocations=2,reallocations=2,requested_bytes=554,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7811 MiB (60% of 13019 MiB available) [systemd MemoryMax, swap off] +operation=read,count=1000,iterations=1,allocations=5010,reallocations=1014,requested_bytes=717402,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7811 MiB (60% of 13018 MiB available) [systemd MemoryMax, swap off] +operation=write,count=1000,iterations=1,allocations=1001,reallocations=2007,requested_bytes=158560,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7811 MiB (60% of 13018 MiB available) [systemd MemoryMax, swap off] +operation=read,count=10000,iterations=1,allocations=50010,reallocations=10019,requested_bytes=7774738,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7814 MiB (60% of 13023 MiB available) [systemd MemoryMax, swap off] +operation=write,count=10000,iterations=1,allocations=10001,reallocations=20011,requested_bytes=2376640,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-build.txt new file mode 100644 index 0000000..70acba9 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-build.txt @@ -0,0 +1,37 @@ +memcap: <=7873 MiB (60% of 13123 MiB available) [systemd MemoryMax, swap off] + Compiling proc-macro2 v1.0.107 + Compiling unicode-ident v1.0.26 + Compiling quote v1.0.47 + Compiling syn v3.0.6 + Compiling serde_core v1.0.229 + Compiling lexical-util v1.0.7 + Compiling memchr v2.8.3 + Compiling serde v1.0.229 + Compiling serde_derive v1.0.229 + Compiling zmij v1.0.23 + Compiling siphasher v1.0.4 + Compiling phf_shared v0.14.0 + Compiling aho-corasick v1.1.5 + Compiling lexical-write-integer v1.0.6 + Compiling lexical-parse-integer v1.0.6 + Compiling fastrand v2.5.0 + Compiling serde_json v1.0.151 + Compiling thiserror v2.0.21 + Compiling regex-syntax v0.8.11 + Compiling regex-automata v0.4.18 + Compiling phf_generator v0.14.0 + Compiling lexical-parse-float v1.0.6 + Compiling lexical-write-float v1.0.6 + Compiling thiserror-impl v2.0.21 + Compiling itoa v1.0.18 + Compiling memo-map v0.3.4 + Compiling minijinja v2.24.0 + Compiling lexical-core v1.0.6 + Compiling phf_codegen v0.14.0 + Compiling regex v1.13.1 + Compiling quick-xml v0.42.0 + Compiling smallvec v1.16.2 + Compiling heck v0.5.0 + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling xml-diagnostics v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate) + Finished `release` profile [optimized + debuginfo] target(s) in 1m 11s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-fixtures.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-fixtures.rs new file mode 100644 index 0000000..f231439 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-fixtures.rs @@ -0,0 +1,85 @@ +use std::hint::black_box; + +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + (catalog_schema, xml.into_bytes()) +} + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-harness.rs new file mode 100644 index 0000000..1fbe95d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-harness.rs @@ -0,0 +1,94 @@ +// Fixture definitions are extracted verbatim from core_benchmarks.rs by run.py. +include!("fixtures.rs"); + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +struct CountingAllocator; +static COUNTING: AtomicBool = AtomicBool::new(false); +static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static REALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static BYTES: AtomicUsize = AtomicUsize::new(0); + +// Diagnostic instrumentation only. The benchmark consumers use System directly. +unsafe impl GlobalAlloc for CountingAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc(layout) } + } + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc_zeroed(layout) } + } + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + REALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(new_size, Ordering::Relaxed); + } + unsafe { System.realloc(ptr, layout, new_size) } + } +} +#[global_allocator] +static ALLOCATOR: CountingAllocator = CountingAllocator; + +fn main() { + let args: Vec = std::env::args().collect(); + let operation = args.get(1).expect("read or write"); + let count: usize = args + .get(2) + .expect("0 for sensor, or catalog count") + .parse() + .unwrap(); + let iterations: usize = args.get(3).expect("iteration count").parse().unwrap(); + let mode = args.get(4).map(String::as_str).unwrap_or("allocations"); + let (schema, xml) = if count == 0 { + build_sensor_fixture() + } else { + build_catalog_fixture(count) + }; + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let root = if count == 0 { "Sensor" } else { "Catalog" }; + let output = serialize(root, &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + for _ in 0..10 { + if operation == "read" { + black_box(deserialize(&xml, Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize(root, &value, &schema, None).unwrap()); + } + } + COUNTING.store(mode == "allocations", Ordering::Relaxed); + measured_region(operation, iterations, &xml, &value, root, &schema); + COUNTING.store(false, Ordering::Relaxed); + println!("operation={operation},count={count},iterations={iterations},allocations={},reallocations={},requested_bytes={},input_bytes={},output_bytes={},field_schema_bytes={},scalar_type_bytes={},value_type_bytes={},poly_value_bytes={}", + ALLOCATIONS.load(Ordering::Relaxed), REALLOCATIONS.load(Ordering::Relaxed), BYTES.load(Ordering::Relaxed), xml.len(), output.len(), + std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::()); +} + +#[inline(never)] +#[no_mangle] +fn measured_region( + operation: &str, + iterations: usize, + xml: &[u8], + value: &polyxml::PolyValue, + root: &str, + schema: &Arc, +) { + for _ in 0..iterations { + if operation == "read" { + black_box(deserialize(black_box(xml), Arc::clone(schema)).unwrap()); + } else { + black_box(serialize(root, black_box(value), schema, None).unwrap()); + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-metadata.json new file mode 100644 index 0000000..6a293cc --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate-metadata.json @@ -0,0 +1,8 @@ +{ + "revision": "ac485e0421cadd8781e044e1f658932a532b0438", + "core_status": "", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n", + "executable": "/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics", + "profile": "release debug=1; allocation instrumentation; not used for latency numbers" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate.lock new file mode 100644 index 0000000..1614ee2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/candidate.lock @@ -0,0 +1,317 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-diagnostics" +version = "0.0.0" +dependencies = [ + "polyxml", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-annotated.txt new file mode 100644 index 0000000..2b70f52 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-annotated.txt @@ -0,0 +1,209 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/candidate/read-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 89728348 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics read 1000 25 instructions (PID 373371, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +296,585,254 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +21,680,675 ( 7.31%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +13,926,225 ( 4.70%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +11,858,578 ( 4.00%) ???:0x00000000000b2400 [/usr/lib/x86_64-linux-gnu/libc.so.6] +10,868,100 ( 3.66%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +10,352,875 ( 3.49%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 9,477,175 ( 3.20%) crates/polyxml-core/src/parser.rs:::parse_sub_tree::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 8,900,000 ( 3.00%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs: as core::hash::Hasher>::write [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 7,805,073 ( 2.63%) ???:0x00000000000b20e0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 6,602,200 ( 2.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 6,401,100 ( 2.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 5,426,700 ( 1.83%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs:::feed [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 5,127,950 ( 1.73%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,625,000 ( 1.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs:::hash_one::<&[u8]> + 4,403,350 ( 1.48%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,058,539 ( 1.37%) ???:0x00000000001972a0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 3,650,000 ( 1.23%) crates/polyxml-core/src/converters.rs:::parse_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 3,275,600 ( 1.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 3,150,700 ( 1.06%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 3,001,875 ( 1.01%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 3,000,000 ( 1.01%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::hash_one::<&[u8]> + 2,825,000 ( 0.95%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::find:: + 2,801,425 ( 0.94%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::parse_sub_tree::<&[u8]> + 2,625,750 ( 0.89%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,550,000 ( 0.86%) crates/polyxml-core/src/parser.rs:polyxml::parser::is_nil_element [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,475,825 ( 0.83%) crates/polyxml-core/src/parser.rs:polyxml::parser::namespace_scope [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,475,550 ( 0.83%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_sub_tree::<&[u8]> + 2,414,886 ( 0.81%) ???:0x00000000000b0f70 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 2,375,000 ( 0.80%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::hash_one::<&[u8]> + 2,325,000 ( 0.78%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::check_for_duplicates [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,200,000 ( 0.74%) /rust/deps/hashbrown-0.17.1/src/raw.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,175,000 ( 0.73%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::next + 2,076,050 ( 0.70%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_start + 2,025,675 ( 0.68%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_end [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,025,675 ( 0.68%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_start [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 2,001,075 ( 0.67%) crates/polyxml-core/src/parser.rs:::parse_attributes [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,950,800 ( 0.66%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,948,250 ( 0.66%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,900,350 ( 0.64%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::next + 1,800,000 ( 0.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::find:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,583,400 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs:::parse_scalar + 1,525,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::parse_sub_tree::<&[u8]> + 1,500,150 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 1,500,000 ( 0.51%) /rust/deps/hashbrown-0.17.1/src/map.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 1,500,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs:::hash_one::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,489,425 ( 0.50%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,465,250 ( 0.49%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,366,800 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::next + 1,357,775 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,350,275 ( 0.46%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,350,000 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::grow_one [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,275,425 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs:::emit_end + 1,226,475 ( 0.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::finish + 1,225,425 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:; 8]>>::from_elem + 1,200,400 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,200,000 ( 0.40%) crates/polyxml-core/src/parser.rs:polyxml::parser::record_content_token [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,199,850 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 1,151,775 ( 0.39%) crates/polyxml-core/src/parser.rs:::finish [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 1,150,300 ( 0.39%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:::feed + 1,075,300 ( 0.36%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 1,050,400 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,050,300 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:::feed + 1,050,300 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_end + 1,050,150 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_sub_tree::<&[u8]> + 1,000,000 ( 0.34%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::parse_sub_tree::<&[u8]> + 975,000 ( 0.33%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 950,100 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::next + 900,750 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_sub_tree::<&[u8]> + 900,525 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 900,300 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 900,275 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_end + 900,100 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 897,350 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_scalar + 850,150 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 850,000 ( 0.29%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::local_name [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 850,000 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_sub_tree::<&[u8]> + 850,000 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::local_name + 800,575 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_start + 800,250 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 800,100 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:::parse_sub_tree::<&[u8]> + 800,000 ( 0.27%) crates/polyxml-core/src/parser.rs:::new [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 775,475 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::finish + 775,000 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::try_allocate_in [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 750,250 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 750,250 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_start + 750,000 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::next + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs: as core::hash::Hasher>::write + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs:::hash_one::<&[u8]> + 700,700 ( 0.24%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]>>::from_elem [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 700,250 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 700,225 ( 0.24%) crates/polyxml-core/src/parser.rs:::push_list_item [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 700,000 ( 0.24%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 675,675 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 675,225 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_start + 675,150 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 675,000 ( 0.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::unescape [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 650,125 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::namespace_scope + 608,450 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::parse_scalar + 603,525 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 600,600 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,200 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,150 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:core::ptr::drop_glue::> + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::is_nil_element + 575,050 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs:::parse_sub_tree::<&[u8]> + 575,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs:::parse_scalar + 550,550 ( 0.19%) crates/polyxml-core/src/parser.rs:polyxml::parser::resolve_record_schema [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 550,550 ( 0.19%) crates/polyxml-core/src/schema.rs:polyxml::schema::validate_content [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 550,350 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::finish + 525,175 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_end + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::check_for_duplicates + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::check_for_duplicates + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs:__rustc::__rust_alloc + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_alloc + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs:::try_fast_path:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_text [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 500,000 ( 0.17%) /rust/deps/hashbrown-0.17.1/src/lib.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::hash::Hasher>::write + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::map_or::<&str, >::from::{closure#0}> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_attributes + 500,000 ( 0.17%) crates/polyxml-core/src/parser.rs:polyxml::parser::parse_field_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:>; 4]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 466,875 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 452,375 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 450,150 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_end + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::emit_start + 450,100 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs:::parse_scalar + 450,050 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 425,850 ( 0.14%) ???:0x00000000000b2300 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 422,350 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 419,500 ( 0.14%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs:::parse_scalar + 400,400 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 400,300 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,125 ( 0.13%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,100 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::feed + 400,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/collections/hash/map.rs:::parse_sub_tree::<&[u8]> + 377,250 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 375,425 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_start + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:::parse_attributes + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::emit_start + 375,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::next + 350,100 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::feed + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::push_mut [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::hash::Hasher>::write + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 325,050 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::parse_sub_tree::<&[u8]> + 300,300 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::into_boxed_slice [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 300,200 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::finish + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,075 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::namespace_scope + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::emit_end + 300,025 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::parse_sub_tree::<&[u8]> + 300,025 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::name + 300,000 ( 0.10%) /rust/deps/hashbrown-0.17.1/src/control/tag.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::is_nil_element + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::check_for_duplicates + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::name + 291,750 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs:::next + 275,050 ( 0.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_attributes + 250,500 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:__rustc::__rust_alloc + 250,500 ( 0.08%) benchmarks/rust-runtime-investigation/target/candidate/src/main.rs:__rustc::__rust_alloc [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 250,475 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::finish + 250,050 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs:::parse_scalar + 250,000 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs:::parse_scalar + 250,000 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::parse_sub_tree::<&[u8]> + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:::parse_attributes + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::parse_attributes + 250,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_scalar + 226,525 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 225,225 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:polyxml::parser::resolve_record_schema + 225,100 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::push_list_item + 225,075 ( 0.08%) crates/polyxml-core/src/schema.rs:::finish + 225,050 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_end + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-valgrind.txt new file mode 100644 index 0000000..49e36e9 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000-valgrind.txt @@ -0,0 +1,12 @@ +==373371== Callgrind, a call-graph generating cache profiler +==373371== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==373371== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==373371== Command: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics read 1000 25 instructions +==373371== Parent PID: 365338 +==373371== +==373371== For interactive control, run 'callgrind_control -h'. +==373371== +==373371== Events : Ir +==373371== Collected : 296585254 +==373371== +==373371== I refs: 296,585,254 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000.callgrind new file mode 100644 index 0000000..3b62a9d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/read-1000.callgrind @@ -0,0 +1,3680 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 373371 +cmd: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics read 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 89728348 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 296585254 + + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4508) 0x00000000000b20e0 +0 4946685 +cfn=(4954) 0x00000000000b0f70 +calls=73313 0 +0 1086761 +0 2459238 +cfn=(4954) +calls=35010 0 +0 548102 +0 399150 + +fn=(4330) 0x00000000000b08d0 +0 120120 + +fn=(4488) 0x0000000000197a00 +0 21680675 + +fn=(4162) 0x000000000002a580 +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4176) main +calls=1 0 +0 296585254 + +fn=(4232) 0x00000000000b2400 +0 10553314 +cfn=(4954) +calls=35955 0 +0 780023 +0 1272808 +cfn=(4330) +calls=32761 0 +0 117485 +0 8432 +cfn=(4330) +calls=799 0 +0 2635 +0 24024 + +fn=(4226) malloc +0 796400 +cfn=(4232) +calls=73729 0 +0 12746428 +0 3606950 + +fn=(4460) 0x00000000000b4180 +0 1109825 +cfn=(4232) +calls=64 0 +0 12293 +0 325500 +cfn=(4502) 0x00000000000b2300 +calls=37042 0 +0 3506272 +0 25225 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=63 0 +0 325 +0 150 +cfn=(4502) +calls=63 0 +0 2925 +0 4550 + +fn=(4954) +0 2414886 + +fn=(4128) (below main) +cfn=(4162) +calls=1 0 +0 296585254 + +fn=(4458) realloc +0 1670225 +cfn=(4460) +calls=38415 0 +0 4987065 +0 278025 + +fn=(4880) free +0 597300 +cfn=(4508) +calls=73670 0 +0 6356589 +0 4530650 + +fn=(4502) +0 300600 +cfn=(4508) +calls=37105 0 +0 3083347 +0 125250 + +fn=(5756) 0x00000000001972a0 +0 4058539 + +ob=(3) +fl=(3) +fn=(4486) +0 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=114 0 +0 275 + +ob=(6) +fl=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +fn=(5714) >::map_or::<&str, >::from::{closure#0}> +1222 100000 ++5 200000 ++4 200000 + +fl=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(5782) quick_xml::escape::unescape +236 250000 ++52 25000 +fi=(54) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs +473 75000 +0 25000 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 50000 +fi=(78) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs +153 125000 +cfi=(84) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs +cfn=(5494) memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 +calls=37000 659 +* 1053000 +fi=(41) +2869 50000 +fe=(107) +321 50000 +fi=(91) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs +0 25000 +fe=(107) +327 100000 +0 25000 +238 225000 + +fl=(85) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs +fn=(5506) <&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: +211 1800600 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +3101 150050 +1032 300100 ++1 100 +cfi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +cfn=(5510) >::grow_one +calls=74 186 +* 4800 +fi=(32) +611 150050 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +1963 150050 +fi=(33) +1038 450150 +fi=(76) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs +137 150050 +fe=(85) ++86 150050 +0 450150 +232 450150 +cfi=(87) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs +cfn=(5518) ::feed +calls=222074 57 +* 14181000 +* 300100 +0 150050 +233 450150 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +1092 150050 +fi=(32) +616 150050 +fi=(33) +1461 150050 +fi=(10) +2689 150050 +fi=(32) +764 150050 +-94 150050 +fi=(33) +2981 300000 +0 150050 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 150050 +fi=(18) +573 750250 +cob=(2) +cfi=(2) +cfn=(4488) +calls=222074 0 +* 2200650 +* 300100 +fi=(33) +2986 450150 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +90 150050 +fi=(141) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs +389 450150 +fe=(85) +239 600200 +fi=(44) +544 450150 +90 300100 +fe=(85) +240 300100 +cfi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +cfn=(5184) core::str::converts::from_utf8 +calls=222074 89 +* 12090575 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +0 300100 +2177 300100 +fe=(85) +253 1200400 +0 150050 +240 600200 +fi=(33) +0 50 +fi=(32) +672 300 +cfn=(5534) >::reserve::do_reserve_and_handle:: +calls=74 -14 +* 6600 +* 100 +fi=(33) +3101 50 +2981 50 +fe=(85) + +fl=(98) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs +fn=(5636) ; 8]>>::from_elem +2052 250250 ++1 50050 +856 25025 +fi=(18) +-9 25025 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2144 25025 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 25025 +fe=(98) +0 25025 +fi=(41) +2274 50050 ++2 25025 +fi=(18) +1963 400400 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fe=(98) +2615 50050 +2067 75075 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 ++2 225225 + +fn=(5962) ; 8]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(5988) >; 4]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +0 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(5998) >; 4]>>::resize_with::<::push_list_item::{closure#0}> +1841 200 +1082 75 +-30 25 +0 25 +1846 75 +1082 50 +-17 25 +0 25 +1358 75 +0 50 +1230 50 +fi=(20) +970 25 +fi=(18) +1963 100 +fe=(98) +1237 25 +fi=(19) +2144 25 +fi=(34) +1100 50 +fi=(74) /home/bailey/github/PolyXML/crates/polyxml-core/src/parser.rs +70 25 +fe=(98) +1082 50 +1217 25 +1856 200 + +fn=(6136) >; 4]> as core::ops::drop::Drop>::drop +2483 250 ++10 50 +-8 200 + +fl=(33) +fn=(5818) >::push_mut +1027 125000 ++2 25000 ++3 50000 +fi=(20) +-62 50000 +fi=(18) +1963 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fe=(33) +1038 50000 ++4 100000 + +fn=(5968) >>::into_boxed_slice +1723 100100 +fi=(32) +616 25025 +fe=(33) +1598 75075 +fi=(32) +832 25025 +fi=(10) +1401 25025 +fi=(32) +839 50050 +fi=(10) +1401 25025 +fi=(23) +228 75075 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/src/main.rs +cfn=(5542) __rustc::__rust_realloc +calls=37037 41 +* 7260022 +fi=(27) +965 50050 +fe=(33) +1731 125125 + +fl=(74) +fn=(5582) ::check_root +343 200 ++1 50 ++14 25 ++1 200 + +fn=(5696) polyxml::parser::record_content_token +1123 525000 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +454 75000 +fi=(41) +634 75000 +fe=(74) +1128 75000 ++8 600000 + +fn=(5602) polyxml::parser::namespace_scope +174 525175 ++1 75025 +fi=(101) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs +0 75025 +fi=(100) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +272 75025 +fe=(74) +-96 975325 +0 75025 +fi=(99) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs +403 225075 +cfi=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +cfn=(5604) ::next +calls=111037 601 +* 12009850 +* 75000 +cfi=(94) +cfn=(5604) +calls=37000 601 +* 1350000 +fi=(95) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs +855 300075 +fi=(41) +-90 50000 +fi=(95) ++90 200050 ++1 150000 +fi=(77) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs +21 50000 +fi=(76) +2635 25000 +fi=(18) +847 75000 +fi=(96) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/collections/hash/map.rs +0 75025 +fe=(74) +187 75025 +cfi=(18) +cfn=(5616) core::ptr::drop_glue::> +calls=111037 847 +* 2300450 ++1 75025 +fi=(41) +1162 150050 +fi=(13) +4029 75025 +fi=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2434 75025 +fe=(74) +189 675225 + +fn=(5896) polyxml::parser::parse_field_scalar +137 150000 ++5 50000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +151 150000 +cfi=(108) /home/bailey/github/PolyXML/crates/polyxml-core/src/converters.rs +cfn=(5794) ::parse_scalar +calls=74000 28 +* 21578803 ++1 150000 + +fn=(5622) polyxml::parser::resolve_record_schema +220 200200 +fi=(14) +454 25025 +fe=(74) +225 50050 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) +3101 50050 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fi=(33) +3126 25025 +fe=(74) +225 25025 +fi=(13) +4029 25025 +fi=(59) +2434 25025 +fe=(74) +226 25025 +0 25025 +274 225225 + +fn=(5994) ::push_list_item +67 175000 +fi=(98) +1082 75000 +-30 25000 +-15 25000 +fe=(74) +68 25000 +-68 24975 +fi=(98) +1082 24975 +-17 24975 +fi=(44) +195 50000 +fi=(98) +1082 25000 +-17 25000 +fe=(74) +0 25 +68 50 +fi=(14) +454 25 +fi=(33) +3101 25 +fe=(74) +70 50 +cfi=(98) +cfn=(5998) +calls=37 1841 +* 1200 +-70 25 +fi=(98) +1082 100 +-17 50 +fe=(74) +72 25000 +fi=(44) +197 50000 +fe=(74) +73 75000 ++1 199800 +fi=(33) +1029 24975 ++3 49950 ++1 450 +cfi=(32) +cfn=(6014) >::grow_one +calls=333 186 +* 46350 +fi=(32) +611 24975 +fi=(20) +970 24975 +fi=(18) +1963 199800 +fi=(33) +1038 74925 +fi=(23) +128 25 +cfi=(6) +cfn=(5102) __rustc::__rust_no_alloc_shim_is_unstable_v2 +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5104) __rustc::__rust_alloc +calls=37 -89 +* 1050 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +251 50 +fe=(74) +75 225 +fi=(18) +847 50 +fe=(74) +75 75 ++3 175000 + +fn=(5592) ::parse_sub_tree::<&[u8]> +410 350 +cfi=(6) +cfn=(5102) +calls=37 0 +* 25 +fi=(23) +130 75 +cfi=(24) +cfn=(5104) +calls=37 -89 +* 3725 +fi=(32) +470 50 +fi=(33) +969 75 +fi=(23) +128 25 +cfi=(6) +cfn=(5102) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5104) +calls=37 -89 +* 950 +fi=(28) +251 50 +fe=(74) +418 100 +cfn=(5602) +calls=37 174 +* 3000 +* 25 +fi=(33) +1196 125 +fe=(74) +420 75 +cfn=(5622) +calls=37 220 +* 1050 +fi=(27) +2177 25 +0 25 +2177 50 +fi=(41) +634 25 +fi=(33) +3101 25 +fe=(74) +38 25 ++1 100 +cfi=(98) +cfn=(5636) +calls=37 2052 +* 3225 +-7 25 ++9 75 +-4 150 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 -37 +* 1925 +* 175 +422 75 +cfn=(5640) ::parse_attributes +calls=37 997 +* 3225 +fi=(27) +2177 50 +fe=(74) +0 75 +423 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1029 25 ++3 50 +fi=(20) +-62 75 +fi=(18) +1963 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1038 50 +462 725 +3082 200000 +fi=(85) +412 800000 +cfi=(75) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs +cfn=(5472) >::read_event_impl::<&mut alloc::vec::Vec> +calls=296000 1006 +* 85032514 +* 100 +cfi=(75) +cfn=(5472) +calls=37 1006 +* 24575 +fe=(74) ++20 1000125 +0 200025 +432 600075 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fi=(32) +611 75000 +fi=(76) +282 150000 +fe=(74) +434 150000 +cfn=(5602) +calls=111000 174 +* 19808500 +0 150000 +fi=(33) +1029 75000 ++3 150000 ++1 50 +cfi=(32) +cfn=(5688) >::grow_one +calls=37 186 +* 20993 +fi=(32) +611 75000 +fi=(18) +1963 75000 +fi=(33) +1038 150000 +fe=(74) +435 150000 +784 100000 +fi=(101) +350 100000 +fi=(54) +871 50000 +fi=(33) +3126 50000 +fi=(13) +3994 100000 +fe=(74) +787 50000 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fi=(33) +0 75025 +fi=(13) +4049 75025 +fi=(59) +2868 75025 +fe=(74) +878 150050 +fi=(33) +3101 75025 ++25 75025 +fe=(74) +882 75025 +0 75000 +fi=(41) +634 150000 +fi=(33) +3126 150000 +fi=(76) +282 150000 +fi=(33) +1904 75000 +fi=(76) +305 150000 +fi=(32) +611 150000 +fi=(76) +305 225000 +fi=(14) +454 75000 +fi=(59) +2454 75000 +fe=(74) +441 150000 +cfn=(5696) +calls=111000 1123 +* 1350000 +fi=(33) +3126 75000 +fe=(74) +447 75000 +fi=(78) +153 150000 +cfn=(5844) memchr::arch::x86_64::memchr::memchr_raw::find_avx2 +calls=73999 -75 +* 3000300 +fi=(41) +2869 100000 +fe=(74) +0 75025 +909 300100 ++42 50050 +fi=(33) +2877 50000 +fi=(54) +871 50000 +fi=(18) +1755 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(101) +350 50000 +fi=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +210 75000 +cfi=(92) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs +cfn=(5706) ::find:: +calls=37000 1497 +* 1200000 ++62 175000 +cfi=(41) +cfn=(5714) +calls=37000 1222 +* 125000 +fe=(74) +0 50000 +fi=(11) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs +975 100000 ++1 25000 +fe=(74) +-21 125000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +* 75000 +cfn=(5928) ::finish +calls=37000 80 +* 27532831 +fi=(27) +2177 50000 +0 200000 +2177 50000 +fe=(74) +955 200000 +fi=(33) +1904 25000 +fi=(76) +305 50000 +fi=(32) +611 25000 +fi=(76) +305 75000 +fe=(74) +958 75000 +fi=(76) +305 100000 +fi=(32) +611 50000 +fi=(76) +305 150000 +fi=(14) +454 50000 +fe=(74) +911 100000 +fi=(41) +634 50000 +fe=(74) +802 50000 +975 50 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99950 +0 50000 +fi=(20) +970 50000 +fi=(18) +573 150000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +fi=(33) +2986 150000 +1865 100000 +fi=(44) +238 100000 +fi=(32) +611 50000 +fi=(44) +238 150000 +fe=(74) +915 350000 +fi=(33) +3101 75000 +fe=(74) +464 150000 +fi=(100) +211 150000 +cfi=(101) +cfn=(5700) ::name +calls=111000 0 +* 775000 +* 150000 +fi=(103) +-1 225000 +cfi=(92) +cfn=(5706) +calls=111000 1497 +* 3725000 ++62 525000 +cfi=(41) +cfn=(5714) +calls=111000 1222 +* 375000 +fe=(74) +0 150000 +471 150000 +cfn=(5716) polyxml::parser::is_nil_element +calls=111000 156 +* 20683500 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fe=(74) +0 75000 +fi=(32) +611 75000 +fi=(76) +282 75000 +fi=(14) +454 75000 +fi=(13) +4029 75000 +fi=(59) +2434 75000 +fe=(74) +473 75000 +fi=(59) +2438 75000 +320 75000 +fi=(96) +1039 300000 +cfi=(55) /rust/deps/hashbrown-0.17.1/src/raw.rs +cfn=(5740) , usize, std::hash::random::RandomState>>::get::<[u8]> +calls=111000 1337 +* 19848000 +fe=(74) +474 150000 +0 75000 +474 75000 +fi=(33) +1865 75000 +fi=(44) +238 150000 +fi=(32) +611 75000 +fi=(44) +238 150000 +fe=(74) +479 525000 +0 25000 +479 50000 +fi=(28) +2415 25000 +fe=(74) +492 275000 ++16 50000 +915 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +925 50000 +cfn=(5896) +calls=74000 137 +* 22178803 +fi=(27) +2177 100000 +0 400000 +2177 100000 +fe=(74) +925 400000 ++1 100000 +0 50000 +929 400000 +fi=(98) +1082 100000 +-17 50000 +fe=(74) +0 50000 +fi=(14) +454 25000 +fi=(96) +1039 100000 +cfi=(55) +cfn=(5740) +calls=37000 1337 +* 6550000 +fe=(74) +-76 75000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +969 100000 ++1 250000 +cfn=(5994) +calls=37000 67 +* 1474250 +* 25000 +fi=(98) +0 100000 +fi=(44) +245 200000 +fi=(18) +847 100000 +fe=(74) ++82 250000 +0 450000 +481 100000 +fi=(33) +3082 250000 +fe=(74) +0 75000 +fi=(14) +454 75000 +fi=(13) +4049 75000 +fi=(59) +2868 75000 +fi=(33) +1865 25000 +fi=(76) +282 50000 +fe=(74) +0 25000 +fi=(32) +611 25000 +fi=(76) +282 50000 +fe=(74) +516 75000 +cfn=(5622) +calls=37000 220 +* 1050000 +fi=(27) +2177 25000 +0 25000 +2177 50000 +fe=(74) +521 50000 +cfn=(5766) ::new +calls=37000 30 +* 6950000 +0 25000 +522 125000 +cfn=(5640) +calls=37000 997 +* 28271500 +fi=(27) +2177 50000 +fe=(74) +523 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(33) +996 75000 +cfn=(5818) +calls=37000 +31 +* 2700000 +* 25000 +fi=(59) +0 125000 +fe=(74) +988 400000 +fi=(18) +847 600000 +0 200000 +847 1200000 +fi=(32) +672 150 +cfn=(5534) +calls=37 -14 +* 2875 +fi=(33) +3101 25 +2981 25 +fe=(74) +988 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5686) __rustc::__rust_dealloc +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 3250 +fi=(14) +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(74) +995 200 +fi=(18) +847 75 +0 25 +847 150 +fi=(33) +2877 25 +fi=(32) +611 50 +fi=(18) +1755 75 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fe=(74) +977 75 +cfn=(5928) +calls=37 80 +* 29016 +* 25 + +fn=(5640) +997 200200 ++1 25025 +fi=(101) +0 25025 +fi=(100) +272 25025 +fe=(74) +999 500500 +fi=(99) +403 75075 +cfi=(94) +cfn=(5604) +calls=37037 601 +* 9309850 +* 75000 +cfi=(94) +cfn=(5604) +calls=37000 601 +* 1350000 +fi=(95) +855 150075 +fi=(41) +-90 50000 +fi=(95) ++90 100050 ++1 125000 +fe=(74) +999 25000 +fi=(103) +222 75000 +fi=(77) +21 75000 +fi=(76) +2635 25000 +fe=(74) +0 25000 +1004 50000 +cfi=(103) +cfn=(5722) ::local_name +calls=37000 141 +* 950000 +0 50000 +fi=(14) +454 25000 +fi=(55) +1337 25000 +fi=(51) /rust/deps/hashbrown-0.17.1/src/map.rs +-53 25000 +0 25000 +1287 25000 +241 50000 +cfi=(52) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs +cfn=(5744) ::hash_one::<&[u8]> +calls=37000 694 +* 4625000 +fi=(104) /rust/deps/hashbrown-0.17.1/src/control/tag.rs +47 75000 +fi=(55) +2452 150000 +0 25000 +fi=(18) +573 25000 +fi=(57) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs +1569 75000 +fi=(105) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs +40 50000 +-40 200000 +fi=(58) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/nonzero.rs +628 25000 +fi=(55) +2032 50000 +fi=(20) +1054 75000 +fi=(77) +21 50000 +fi=(106) /rust/deps/hashbrown-0.17.1/src/lib.rs +157 100000 +cob=(2) +cfi=(2) +cfn=(5756) +calls=37000 0 +* 493000 +* 25000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +455 25000 +fe=(74) +1005 25000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +1007 100000 +fi=(101) +350 50000 +fe=(74) +1008 50000 +cfi=(107) +cfn=(5782) +calls=37000 236 +* 2078000 +fi=(27) +2177 25000 +0 100000 +2177 50000 +fe=(74) +0 75000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(74) +1009 75000 +cfi=(108) +cfn=(5794) +calls=37000 28 +* 2767000 +fi=(27) +2177 50000 +0 200000 +2177 75000 +fe=(74) +1009 225000 +fi=(98) ++73 75000 +-17 25000 +fi=(44) +245 50000 +0 25000 +fi=(98) +1082 25000 +-17 25000 +fi=(44) +245 50000 +fi=(18) +847 50000 +fe=(74) +1014 225000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 50000 +fi=(11) +0 25025 +fe=(74) +1024 25025 +cfi=(18) +cfn=(5616) +calls=37037 847 +* 1400450 +* 25025 +fi=(14) +454 25025 +fe=(74) +1025 50050 ++3 25025 +fi=(18) +847 50050 +fe=(74) +1029 225225 + +fn=(5716) +156 525000 +fi=(101) +0 75000 +fi=(100) +272 75000 +fe=(74) +157 1125000 +0 75000 +fi=(99) +403 225000 +cfi=(94) +cfn=(5604) +calls=111000 601 +* 12008500 +* 75000 +cfi=(94) +cfn=(5604) +calls=37000 601 +* 1350000 +fi=(95) +855 300000 +fi=(41) +-90 50000 +fi=(95) ++90 200000 ++1 100000 +fe=(74) +157 25000 +fi=(103) ++65 50000 +fi=(77) +21 50000 +fi=(76) +2635 25000 +fe=(74) +162 50000 +cfi=(103) +cfn=(5722) +calls=37000 -21 +* 950000 +fi=(77) +21 100000 +fi=(18) +847 50000 +fi=(23) +0 150000 +fe=(74) +168 75000 +cfi=(18) +cfn=(5616) +calls=111000 847 +* 2300000 ++2 675000 + +fn=(5470) ::deserialize_with_limit +365 250 +fi=(75) +810 300 +fi=(33) +462 150 +0 50 +fi=(85) +412 100 +cfi=(75) +cfn=(5472) +calls=37 1006 +* 24750 +fe=(74) +-38 225 +fi=(14) ++80 25 +fi=(59) +2454 100 +fe=(74) +376 50 +cfn=(5582) +calls=37 -33 +* 475 +fi=(27) +2177 50 +fe=(74) +379 50 +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/mod.rs +105 75 +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/lazy.rs +-46 50 +fi=(60) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cell.rs +558 50 +fi=(10) +2652 25 +fi=(11) +976 25 +fi=(59) +440 200 +fi=(23) +128 25 +cfi=(6) +cfn=(5102) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5104) +calls=37 -89 +* 1050 +fi=(28) +251 50 +0 25 +293 200 +fi=(59) ++27 75 +fe=(74) ++57 125 +cfn=(5592) +calls=37 +33 +* 284098132 +fi=(13) +4049 25 +fi=(59) +2868 25 +0 50 +2911 25 +cfn=(6144) >>::drop_slow +calls=37 2138 +* 1725 +0 25 +fe=(74) +401 75 +fi=(18) +847 75 +0 25 +847 150 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5686) +calls=37 65 +* 3850 +fe=(74) +408 275 + +fn=(5928) +80 225225 +fi=(14) +454 50050 +fi=(59) +2454 25025 +fi=(32) +611 25025 +fi=(33) +1865 75075 +fe=(74) +81 25025 +cfi=(45) /home/bailey/github/PolyXML/crates/polyxml-core/src/schema.rs +cfn=(5930) polyxml::schema::validate_content +calls=37037 725 +* 550550 +fi=(27) +2177 50050 +fi=(18) +0 50050 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 25025 +0 125125 +180 100100 +fi=(41) +634 25000 +fe=(74) +83 25000 +fi=(50) +-83 75025 +fi=(14) +1663 150050 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +fi=(45) +4 75025 +fe=(74) ++79 75025 +fi=(98) +1082 75000 +-30 25000 +fi=(44) +238 50000 +0 25000 +fi=(98) +1082 25000 +-30 25000 ++30 75075 +-30 25025 +-15 50050 +fe=(74) +96 25025 +-96 50 +fi=(98) +1082 25 +fe=(74) +97 300 +fi=(98) +996 50 ++56 25 +-56 25 +fe=(74) +97 25 +fi=(118) +-73 125 +fe=(74) ++73 25 +fi=(98) +2493 50 +0 125 +fe=(74) +99 200 +fi=(98) +2493 50 +0 25 +2493 50 ++5 50 +1082 50 +-30 25 +fi=(54) +871 25 +fi=(18) +1755 25 +fi=(41) +2869 50 +fi=(118) +80 25 +fi=(41) +2870 50 +fi=(118) +81 25 ++1 50 +fe=(74) ++16 100 ++1 50 +fi=(98) +1082 75 +-17 25 +fi=(44) +245 50 +0 25 +fi=(98) +1082 25 +-17 25 +fi=(44) +245 50 +fi=(18) +847 50 +0 25 +847 25 +cfi=(98) +cfn=(6136) +calls=37 2483 +* 500 +0 75 +847 25 +cfi=(98) +cfn=(5988) +calls=37 2373 +* 550 +0 25 +fi=(14) +454 25 +fe=(74) +104 100 +0 50000 +fi=(14) +454 25000 +fe=(74) +104 75000 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +0 100100 +fi=(98) +1052 125125 +fi=(14) +1663 150050 +fi=(118) +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +0 75025 +fi=(98) +1082 225075 +-30 75025 +fi=(44) +238 150050 +0 75025 +fi=(98) +1082 75025 +-30 75025 +fi=(41) +743 150050 +fi=(45) +-74 150050 +fi=(111) /home/bailey/github/PolyXML/crates/polyxml-core/src/lib.rs +0 25025 +fe=(74) +131 100100 ++1 75075 +fi=(98) +1082 25025 +1607 25025 +fe=(74) +132 25025 +fi=(98) +1615 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 +2552 50050 +-1 150150 +fi=(33) +3996 25025 +cfi=(117) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs +cfn=(5950) > as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter +calls=37037 32 +* 11517075 +0 25025 +fe=(74) +132 25025 +cfi=(33) +cfn=(5968) +calls=37037 1723 +* 7835597 +-2 125125 ++4 50050 +0 25000 +fi=(18) +847 25000 +cfi=(98) +cfn=(5988) +calls=37000 2373 +* 550000 +* 175175 +fi=(32) +425 50050 +631 25025 +fe=(74) +134 225225 + +fn=(5468) polyxml::deserialize +362 50 +cfn=(5470) +calls=37 +3 +* 284135282 + +fn=(5766) +30 150000 +fi=(41) +634 25000 +fi=(33) +3101 25000 +fe=(74) +38 25000 ++1 100000 +cfi=(98) +cfn=(5636) +calls=37000 2052 +* 4175000 +-7 25000 ++9 75000 +-4 125000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 -37 +* 1925000 +* 150000 ++8 150000 + +fl=(114) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs +fn=(5922) ::try_fast_path:: +45 75000 +-45 25000 +46 50000 +-46 50000 +46 100000 ++36 50000 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs ++70 50000 +fe=(114) +-67 50000 ++22 25000 +fi=(116) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/table_decimal.rs +-30 75000 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/arith.rs +515 50000 +fe=(114) +100 75000 + +fl=(101) +fn=(5700) +0 75000 +fi=(100) +202 75000 +fi=(92) +380 150000 +fi=(100) +202 75000 +fi=(92) +384 150000 +fi=(43) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs +1229 25000 +fi=(91) +424 75000 +fi=(100) +203 150000 +fe=(101) + +fl=(87) +fn=(5518) +57 1500500 +fi=(54) +473 450150 +fi=(13) +3994 300100 +fi=(78) +153 900300 +cfi=(84) +cfn=(5524) memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 +calls=222073 1042 +* 4203450 +fi=(41) +2869 300100 +fi=(88) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs +0 150050 +fi=(54) +623 300100 +fe=(87) +59 300100 +fi=(54) +871 150050 +fe=(87) +59 625200 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5524) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fi=(88) +0 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 375100 +-59 150050 +59 600200 +-59 150050 +59 200050 ++14 1350450 +fi=(88) +-73 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 75000 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5524) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fe=(87) + +fl=(90) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs +fn=(5868) ::emit_end +197 525175 +fi=(91) +-68 150050 +fi=(43) +1229 75025 +fi=(91) +145 75025 +fi=(43) +1229 75025 +fi=(91) +262 75025 +0 300100 +fe=(90) +214 225075 +fi=(93) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs +315 300100 +0 75025 +fi=(50) +402 150050 +fi=(93) +-87 75025 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fe=(90) +228 150050 +fi=(32) +611 75025 +fi=(33) +1865 75025 +fi=(92) +380 150050 ++4 150000 +fi=(43) +1229 75000 +fi=(91) +493 75000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1490 150050 +fi=(92) +380 450150 +fi=(32) +611 75000 +fi=(43) +1229 75000 +fi=(40) +1491 75000 +fi=(33) +1828 75025 +fe=(90) +257 375125 ++1 675225 +fi=(92) +384 225075 +fi=(91) +221 150050 +fi=(54) +871 75025 +fi=(77) +21 150050 +-21 75025 +157 600200 +cob=(2) +cfi=(2) +cfn=(5756) +calls=111037 0 +* 1617539 +* 450150 +fe=(90) ++73 75025 +fi=(92) +394 75025 +fi=(91) ++30 75025 +fe=(90) + +fn=(5556) ::emit_start +314 750250 +fi=(92) ++70 150050 +fi=(43) +1229 75025 +fi=(91) +493 75025 +0 75025 +221 150050 +fi=(76) +2736 150050 +fi=(77) +157 75025 +fi=(76) +2738 75025 +0 75025 +2738 75025 +fe=(90) +345 150050 +fi=(10) +1092 75025 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 75025 +fi=(91) +424 75025 +0 225075 +fi=(93) +331 325175 +-4 650350 ++1 700350 +-13 350175 +0 50000 +fi=(33) +3101 25000 +1029 25000 ++3 50000 +fi=(32) +611 75025 +fi=(18) +1963 75025 +fi=(33) +1038 150050 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 25000 +fi=(91) +424 25000 +fi=(33) +1033 100 +cfi=(32) +cfn=(5572) >::grow_one +calls=37 186 +* 2675 +* 75 +0 50025 +3101 50025 +1029 50025 ++3 100075 +fi=(91) +424 50025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +0 75025 +fi=(20) +970 75025 +fi=(18) +573 300100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=111037 0 +* 1125375 +* 75025 +fi=(33) +2986 225075 +fe=(90) +0 450150 +356 675225 +fi=(32) +672 250 +cfn=(5534) +calls=74 -14 +* 5825 +* 50 +fi=(33) +3101 100 +fe=(90) + +fn=(5832) ::emit_text +63 50000 ++1 100000 ++11 200000 ++1 150000 + +fl=(6) +fn=(4126) (below main) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 296585254 + +fn=(4176) +cfi=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +cfn=(4178) std::rt::lang_start_internal +calls=1 152 +0 296585254 + +fn=(5102) +0 125250 + +fl=(117) +fn=(5950) +32 200200 +fi=(98) +2493 100100 +0 25025 +2498 50050 +1082 25025 +-30 25025 +fi=(37) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs +0 25025 +26 225225 +fi=(98) +2506 25025 +fi=(10) +-10 75075 +fi=(19) +1051 75075 +fi=(10) +3212 25025 +fi=(37) +0 25025 +fi=(47) +478 75075 +fi=(98) +1052 25025 +fi=(54) +871 25025 +fi=(18) +1755 25025 +fi=(37) +24 50050 +fe=(117) ++10 200200 +fi=(32) +461 50050 +0 25025 +cfi=(6) +cfn=(5102) +calls=37037 0 +0 25025 +0 25025 +fi=(23) +130 75075 +cfi=(24) +cfn=(5104) +calls=37037 -89 +* 4837200 +fi=(32) +470 50050 +0 50050 +fi=(18) +1963 200200 +fi=(37) +36 100100 ++5 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 -41 +* 1926925 +fi=(98) +2493 125125 +0 50 +2493 50 +0 100000 +fi=(33) +4100 225000 +fi=(18) +1963 400000 +fi=(33) +4111 50000 +2224 50000 +fi=(98) +2493 150000 ++5 100000 +fi=(18) +1755 50000 +fi=(33) +4100 550000 ++2 100000 +fi=(98) +0 75000 +2493 50000 +0 25025 +fi=(18) +847 25025 +cfi=(98) +cfn=(5962) +calls=37037 2373 +* 525525 +fi=(37) +42 150150 +fe=(117) + +fl=(84) +fn=(5494) +659 350100 +fi=(78) +0 700200 +fi=(54) +623 350100 +fe=(84) ++40 350100 ++1 50100 +fi=(88) +1161 50050 +0 25025 +1162 25025 +fe=(84) +668 50050 +fi=(88) +1162 47250 +fe=(84) +668 239000 +fi=(54) +389 72250 +fi=(88) +1161 144500 +0 25000 +fi=(78) +86 75000 +fi=(18) +573 150000 +fi=(145) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs +699 300000 +2315 150000 +2163 150000 +fi=(146) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/vector.rs +147 150000 +fi=(88) +679 150000 +fi=(18) +573 25 +fi=(57) +920 50 +-25 25 +1569 25 +fi=(146) +147 25 +fi=(88) +679 25 +fe=(84) +0 450075 +fi=(78) +86 300100 +fe=(84) + +fn=(5524) +1042 400100 +0 1400350 +fi=(54) +623 400100 +fe=(84) +1046 400100 ++1 150 +fi=(88) +1161 50 +0 25 +1162 50 +fe=(84) +1051 25 +fi=(88) +1162 400 +fe=(84) +1051 1050 +fi=(54) +389 200 +fi=(88) +1161 400 +fi=(18) +573 199975 +fi=(145) +699 399950 +2315 199975 +699 199975 +2315 199975 +2163 199975 +fi=(146) +147 199975 +fi=(88) +972 199975 +fi=(18) +573 50 +fi=(57) +920 100 +-25 50 ++25 50 +-25 50 +1569 50 +fi=(146) +147 50 +fi=(88) +972 50 +fe=(84) +0 800100 +fi=(78) +86 400050 +-86 25 +86 50 +fe=(84) + +fl=(75) +fn=(5472) +1006 2400600 +289 1400350 +fi=(76) +2635 50 +fi=(77) +157 125 +fi=(85) +24 25 +fe=(75) +306 25 ++45 300100 +fi=(33) +3101 150050 +fi=(76) +137 300100 +0 300100 +fi=(54) +871 150050 +fi=(13) +3994 300100 +fi=(78) +153 750250 +cfi=(84) +cfn=(5494) +calls=222073 659 +* 3301100 +fi=(41) +2869 300100 +fi=(85) +72 600200 ++7 100000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 100000 +-94 50000 +fi=(20) +970 50000 +fi=(18) +573 200000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +* 100000 +fi=(33) +2986 100000 +fi=(85) +0 50000 +fi=(44) +549 100000 +fi=(141) +389 100000 +fi=(44) +544 50000 +fi=(85) +79 100000 +fi=(44) +544 150000 +90 100000 +fi=(85) +-4 150000 +cfi=(38) +cfn=(5184) +calls=74000 +3 +* 3700250 +* 100000 +-25 150000 ++14 100050 +fi=(141) +389 100050 +fe=(75) +-34 100050 +0 300150 +437 100050 +fi=(44) +544 200100 +fe=(75) +437 50000 +fi=(44) +544 100000 +fe=(75) +0 150050 +fi=(141) +389 300100 +fi=(44) +90 150050 +fi=(76) ++66 300100 +fi=(141) +389 300100 +fi=(76) +156 150050 +fi=(72) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs +716 300100 +fe=(75) +440 600200 +0 75025 +464 225075 +cfi=(85) +cfn=(5506) +calls=111037 211 +* 19183725 +-1 150050 ++4 375125 +cfi=(90) +cfn=(5868) +calls=111037 197 +* 8894789 +* 75025 +0 75025 +488 225075 +cfi=(85) +cfn=(5506) +calls=111037 211 +* 22204750 +-1 150050 +0 250000 +cfi=(90) +cfn=(5832) +calls=74000 63 +0 500000 +fi=(27) +2177 50000 +0 200000 +2177 100000 +fe=(75) +0 300000 +323 50000 +491 375125 +cfi=(90) +cfn=(5556) +calls=111037 314 +* 9137500 +* 75025 +-91 750250 +1011 1800450 + +fl=(55) +fn=(5740) +1337 100000 +fi=(51) +-53 100000 +0 900000 +1287 200000 +241 200000 +cfi=(52) +cfn=(5744) +calls=148000 694 +* 18150000 +fi=(104) +47 300000 +fe=(55) +2452 800000 +0 100000 +fi=(18) +573 100000 +fi=(57) +1569 300000 +fi=(105) +40 200000 +-40 500000 +fi=(58) +628 100000 +fe=(55) +2032 200000 +fi=(20) +1054 300000 +fi=(77) +21 200000 +fi=(106) +157 400000 +cob=(2) +cfi=(2) +cfn=(5756) +calls=148000 0 +* 1948000 +* 100000 +fi=(47) +455 100000 +fe=(55) +1217 1000000 +fi=(51) ++76 100000 +fe=(55) + +fn=(6146) as core::ops::drop::Drop>::drop +3486 175 +2656 50 +2271 25 +3498 200 + +fl=(18) +fn=(6386) core::ptr::drop_glue:: +847 275 +fi=(14) +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(18) +847 450 +cfn=(6387) core::ptr::drop_glue::'2 +calls=37 * +* 12447414 +* 200 +cob=(2) +cfi=(2) +cfn=(4880) +calls=37 0 +* 825 + +fn=(6387) +847 275 +fi=(32) +611 25 +fi=(33) +4358 25 +fe=(18) +847 125 +0 25 +847 50 +cfn=(6387) +calls=37 * +* 8314 +* 49950 +cfn=(6387) +calls=36963 * +* 12284032 +* 100000 +fi=(32) +631 50 +fe=(18) +847 175 +cob=(2) +cfi=(2) +cfn=(4880) +calls=37 0 +* 4368 +* 1700000 +fi=(32) +631 50000 +425 25000 +fi=(23) +312 25000 +fi=(14) +454 25000 +fi=(13) +4049 25000 +fi=(59) +2868 25000 +fe=(18) +847 900000 +cfn=(6387) +calls=111000 * +* 6176136 +* 525000 +cob=(2) +cfi=(2) +cfn=(4880) +calls=74000 0 +* 8992346 + +fn=(5616) +847 700200 +fi=(32) +425 350100 +631 175050 +425 75000 +fi=(10) +1401 75000 +fi=(23) +175 150000 +cfi=(26) +cfn=(5686) +calls=111000 65 +* 2550000 +fe=(18) +847 1925550 + +fl=(94) +fn=(5660) ::check_for_duplicates +1036 525000 ++5 150000 +0 150000 +fi=(33) +3101 75000 +fe=(94) +1042 150000 +0 300000 +fi=(32) +611 150000 +fi=(20) +970 300000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fe=(94) +0 225000 +fi=(33) +1032 150000 ++1 75000 +cfi=(32) +cfn=(5664) >>::grow_one +calls=111000 186 +* 8025000 +fi=(32) +611 150000 +0 225000 +fi=(18) +1963 225000 +fi=(33) +1038 225000 +fe=(94) ++16 225000 ++1 600000 + +fn=(5604) +601 1500300 ++1 1000200 +cfn=(5606) ::next +calls=370074 1123 +* 28202100 +* 1250250 ++1 350100 ++1 450000 +fi=(91) +129 525000 +fe=(94) +777 225000 +fi=(91) +129 150000 ++4 150000 ++12 150000 +fi=(43) +1229 150000 +fi=(91) +146 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +129 375000 ++4 150000 ++12 150000 +fi=(43) +1229 75000 +fi=(91) +145 75000 ++1 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +fi=(54) +871 225000 +fe=(94) +604 375000 ++3 1250250 + +fn=(5606) +1123 1750350 ++1 750150 +955 750150 ++2 250050 +1124 250050 +fi=(44) +544 500100 +fi=(14) +1663 500100 +fi=(50) +180 250050 +fe=(94) +1125 75000 +fi=(44) +90 375000 +-90 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +0 225000 +fi=(50) +180 75000 +fe=(94) +0 75000 +fi=(50) +180 75000 +fe=(94) +1138 175050 ++1 175050 +0 75000 +fi=(50) +180 75000 +fe=(94) +1143 300000 +fi=(14) +1663 150000 +fi=(50) +180 75000 +fe=(94) +1143 450000 +0 375000 +1188 525000 +0 175050 +1261 2250450 +-73 450000 +cfn=(5660) +calls=111000 1036 +* 12075000 +* 150000 +fi=(14) +1663 300000 +fi=(50) +180 75000 +0 225000 +fe=(94) +1199 150000 +fi=(93) +315 75000 +0 150000 +fe=(94) +0 225000 +fi=(14) +1663 150000 +fi=(50) +180 300000 +fe=(94) +1243 75000 +fi=(147) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs +2490 75000 +fe=(94) +1243 216750 +fi=(147) +2490 216750 +fi=(14) +627 216750 +1663 433500 +fi=(50) +180 216750 +fi=(93) +0 150000 +fe=(94) +1243 75000 +0 150000 +1243 150000 +1113 150000 +0 375000 + +fl=(8) +fn=(5138) std::rt::lang_start::<()>::{closure#0} +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5140) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 296585254 + +fn=(4178) +fi=(148) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5138) +calls=1 206 +287 296585254 +fe=(8) + +fl=(45) +fn=(5930) +725 200200 ++1 100100 +0 25025 +735 225225 + +fl=(30) +fn=(5140) +fi=(148) +cfi=(24) +cfn=(5142) xml_diagnostics::main +calls=1 43 +250 296585254 +fe=(30) + +fl=(53) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs +fn=(5294) as core::hash::Hasher>::write +256 250000 ++2 250000 ++4 750000 +0 500000 +278 250000 ++1 750000 ++3 500000 +0 625000 +fi=(18) +573 125000 +fe=(53) +288 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fe=(53) +78 125000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 250000 +fe=(53) +78 125000 +290 125000 ++2 125000 +-10 250000 +0 500000 +126 500000 +fi=(18) +573 200000 +fe=(53) +132 400000 +0 300000 +132 450000 +fi=(54) +871 25000 +fi=(18) +573 25000 +fe=(53) +134 75000 ++1 25000 ++2 500000 ++2 150000 +298 25000 +0 25000 +300 50000 +-2 225000 +0 225000 +300 450000 + +fl=(78) +fn=(5844) +78 50000 +fi=(84) +184 100000 +0 150000 +fi=(54) +623 100000 +fi=(84) +188 100000 ++1 100000 +fi=(88) +1161 50000 +0 50000 +fi=(84) +193 1050150 +fi=(54) +389 350050 +fi=(88) +1161 700100 +0 100000 +fe=(78) +86 100000 + +fl=(52) +fn=(5744) +694 750000 ++5 125000 +fi=(53) +203 250000 +fi=(48) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs +84 125000 +fi=(53) +204 250000 +fi=(48) +84 625000 +fi=(10) +4058 375000 +fi=(53) +233 375000 +cfn=(5294) +calls=185000 +23 +* 6875000 +* 500000 +cfn=(5294) +calls=185000 +23 +* 3650000 ++81 375000 +-2 250000 ++4 250000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 250000 +fi=(53) +78 125000 +318 125000 ++2 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 500000 +fi=(53) +323 375000 +fe=(52) +702 625000 + +fl=(108) +fn=(5794) +28 1275000 ++5 1275000 +fi=(111) +-33 25000 +fi=(76) +199 25000 +fi=(56) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs +434 50000 +0 25000 +434 75000 +fi=(76) +0 25000 +fe=(108) +132 75000 +cfi=(38) +cfn=(5184) +calls=37000 -43 +* 1961250 +fi=(27) +0 50000 +2177 50000 +0 25000 +fi=(76) +199 25000 +0 75000 +fi=(56) +434 75000 +fi=(111) +0 25000 +fi=(32) +435 125000 +cfn=(5902) ::try_allocate_in +calls=37000 +12 +* 11703953 +0 25000 +435 75000 ++1 25000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs ++16 50000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 330000 +fe=(108) +133 100000 +0 50000 +209 225000 +0 50000 +209 450000 +fi=(56) +434 150000 +fi=(76) +0 25000 +fi=(56) +434 175000 +fi=(112) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs +175 100000 +fi=(56) +0 25000 +fi=(109) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs +199 150000 +fi=(44) +0 50000 +fi=(113) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs +252 100000 +0 50000 +252 25000 +fi=(109) +677 25000 ++10 25000 +0 75000 +411 50000 +fi=(10) +2689 25000 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +39 50000 +fi=(109) +411 94500 +fi=(10) +2689 47250 +fi=(124) +39 94500 +fi=(110) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs +270 72250 +fi=(149) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 72250 +fi=(115) +132 72250 +fi=(149) +2189 72250 +fi=(44) +184 216750 +0 25000 +fe=(108) +154 75000 +fi=(44) ++30 50000 +fi=(112) +872 205600 +fi=(10) +2689 102800 +fi=(124) +39 205600 +fi=(10) +2728 155600 +fi=(112) +566 77800 +fi=(10) +2652 77800 +fi=(110) +144 77800 +fi=(44) ++40 155600 +fi=(19) +2105 25000 +fi=(112) +616 25000 +0 75000 +fi=(44) +380 50000 +fi=(113) +252 75000 +fi=(44) +-68 50000 +0 25000 +fi=(112) +872 50000 +fi=(10) +2689 25000 +fi=(124) +39 50000 +fi=(112) +872 50000 +fi=(10) +2689 25000 +fi=(124) +39 50000 +fi=(10) +2728 100000 +fi=(112) +623 50000 +fi=(10) +2652 50000 +fi=(110) +144 50000 +fi=(44) ++40 100000 +0 50000 +90 50000 +fi=(112) +616 250000 +-48 100000 +fi=(44) +184 50000 +fi=(110) +0 50000 +fi=(112) +666 50000 +fi=(44) +0 25000 +fi=(112) +747 50000 +0 50000 +855 50000 +216 300000 ++51 25000 +cfi=(114) +cfn=(5922) +calls=37000 45 +* 675000 +* 50000 +0 25000 +fe=(108) +164 75000 + +fl=(103) +fn=(5722) +141 250000 ++69 250000 +fi=(10) +1096 100000 +fi=(44) +90 50000 +fi=(102) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs +-62 100000 ++13 100000 +-41 100000 +42 200000 ++4 100000 +-5 250000 +fi=(54) +-41 50000 +fe=(103) +143 350000 + +fl=(32) +fn=(5232) ::finish_grow +544 2600 +fi=(10) +3212 2600 +fi=(47) +478 975 +0 325 +fe=(32) +631 325 +fi=(10) +1401 300 +fi=(23) +228 1500 +cfi=(24) +cfn=(5542) +calls=1451 41 +* 54143 +fi=(27) +965 600 +fi=(23) +298 50 ++4 25 +cfi=(6) +cfn=(5102) +calls=39 0 +* 25 +130 75 +cfi=(24) +cfn=(5104) +calls=39 -89 +* 950 +fi=(27) +965 50 ++1 975 +fe=(32) +0 650 +564 1950 +-20 600600 +fi=(10) +3212 600600 +fi=(47) +478 225225 +fe=(32) +631 150150 +fi=(10) +1401 25 +fi=(23) +228 125 +cfi=(24) +cfn=(5542) +calls=1037 41 +* 1400 +fi=(27) +965 50 +fi=(23) +298 150100 ++4 75050 +cfi=(6) +cfn=(5102) +calls=111074 0 +* 75050 +130 225150 +cfi=(24) +cfn=(5104) +calls=111074 -89 +* 3152000 +fi=(27) +965 150100 ++1 225225 +fe=(32) +0 150150 +564 450450 +-20 400 +fi=(86) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/layout.rs +75 50 ++38 50 +0 50 +fe=(32) +631 100 +fi=(23) +298 100 +128 50 +cfi=(6) +cfn=(5102) +calls=74 0 +* 50 ++2 150 +cfi=(24) +cfn=(5104) +calls=74 -89 +* 1900 +fi=(27) +965 100 ++1 150 +fe=(32) +0 100 +564 300 + +fn=(5902) +447 225000 +fi=(10) +3212 175000 +fi=(47) +478 50000 +fe=(32) +-17 50000 +0 50000 +cfi=(6) +cfn=(5102) +calls=37000 0 +0 25000 +0 50000 +465 50000 ++13 75000 +0 50000 +483 175000 +fi=(23) +130 25000 +cfi=(24) +cfn=(5104) +calls=37000 -89 +* 10653953 +fe=(32) +470 50000 + +fn=(5664) +186 300000 +493 75000 ++30 75000 +fi=(19) +1051 225000 +fe=(32) +529 450000 +cfn=(5232) +calls=111000 +15 +* 6225000 +fi=(27) +2177 150000 ++1 75000 +fe=(32) +773 75000 ++1 75000 +189 300000 + +fn=(6014) +186 900 +493 225 ++30 225 +fi=(19) +1051 675 +fe=(32) +529 1350 +cfn=(5232) +calls=333 +15 +* 40950 +fi=(27) +2177 450 ++1 225 +fe=(32) +773 225 ++1 225 +189 900 + +fn=(5510) +186 300 +493 50 ++30 50 +fi=(19) +1051 150 +fe=(32) +529 200 +cfn=(5232) +calls=74 +15 +* 3550 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +189 250 + +fn=(5534) +658 300 +512 150 +fi=(10) +938 75 +fi=(47) +478 75 +0 75 +fe=(32) +523 150 +fi=(19) +1051 150 +fe=(32) +159 525 +fi=(19) +1051 225 +fe=(32) +529 300 +cfn=(5232) +calls=1118 +15 +* 6775 +fi=(27) +2177 150 ++1 75 +fe=(32) +773 75 ++1 75 +668 300 +-10 150 +fi=(10) +938 50 +fi=(47) +478 50 +0 50 +fe=(32) +523 100 +fi=(19) +1051 250 +fe=(32) +529 350 +cfn=(5232) +calls=1074 +15 +* 4375 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +668 200 + +fn=(5688) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5232) +calls=37 +15 +* 20393 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fn=(5572) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5232) +calls=37 +15 +* 2075 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fl=(26) +fn=(5686) +65 75200 +cob=(2) +cfi=(2) +cfn=(4880) +calls=112323 -65 +* 2487000 + +fl=(59) +fn=(6144) +2138 75 ++6 25 +fi=(18) +842 25 ++5 25 +cfi=(55) +cfn=(6146) +calls=37 3486 +* 450 +fi=(119) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/rc.rs +3277 25 +fe=(59) +3392 25 +fi=(13) +4049 25 +fe=(59) +3544 25 +fi=(23) +175 175 +cfi=(26) +cfn=(5686) +calls=37 65 +* 850 +fe=(59) + +fl=(24) +fn=(5142) +cfn=(6440) measured_region +calls=1 79 +70 296585254 + +fn=(6440) +79 9 +fi=(19) +2144 1 +fi=(34) +1100 1 +0 10 +fi=(26) +0 5 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 4 +fi=(13) +4029 1 +fi=(59) +2434 1 +fi=(26) +0 24 +fi=(150) +491 96 +fi=(13) +4029 24 +fi=(59) +2434 24 +fe=(24) +89 125 +cfi=(74) +cfn=(5468) +calls=25 362 +* 284135332 +fi=(27) +1230 50 ++1 200 +fe=(24) +89 50 +cfi=(18) +cfn=(6386) +calls=25 847 +* 12449239 +fi=(19) +2144 25 +fi=(34) +1100 25 +fe=(24) +94 8 + +fn=(5104) +41 125250 +fi=(13) +3994 125250 +762 125250 +fe=(24) +16 125250 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 501000 +fi=(26) +30 250500 ++1 250500 +cob=(2) +cfi=(2) +cfn=(4226) +calls=186395 -31 +* 17149778 +fe=(24) + +fn=(5542) +41 25350 +fi=(13) +3994 25350 +762 25350 +fe=(24) +33 25350 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 126750 +405 50700 +fi=(26) +70 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4458) +calls=37037 -71 +* 6884647 +-1 650 ++1 650 +cob=(2) +cfi=(2) +cfn=(4458) +calls=2488 -71 +* 50668 +fe=(24) + +fl=(92) +fn=(5706) +1497 1100000 +fi=(10) +1096 200000 +fi=(44) +90 100000 +fi=(102) +-62 200000 ++13 200000 +-41 200000 +42 850000 ++4 425000 +-5 950000 +fe=(92) +1499 700000 + +fl=(38) +fn=(5184) +89 1125250 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 675150 ++12 450100 +0 1575350 +164 225050 ++1 450100 +fi=(10) +2689 450100 +3875 225050 +fi=(39) +222 225050 ++2 450100 ++17 450100 +0 225050 +241 3590050 ++1 1795025 +-1 3815100 +fe=(38) +94 900200 +-94 225050 +98 900200 + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4126) +calls=1 0 +0 296585254 + +totals: 296585254 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-annotated.txt new file mode 100644 index 0000000..22bbb9f --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-annotated.txt @@ -0,0 +1,92 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/candidate/write-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 28034902 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics write 1000 25 instructions (PID 373380, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +73,143,030 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +7,925,000 (10.83%) crates/polyxml-core/src/serializer.rs:::write_model::<&mut alloc::vec::Vec>'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +6,239,550 ( 8.53%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +5,451,300 ( 7.45%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs:>>::write_event:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +4,801,200 ( 6.56%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,962,775 ( 4.05%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,500,200 ( 3.42%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +2,240,625 ( 3.06%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs:::format_scalar_to +2,100,350 ( 2.87%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +2,100,000 ( 2.87%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::write_model::<&mut alloc::vec::Vec>'2 +2,050,200 ( 2.80%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> +2,012,750 ( 2.75%) crates/polyxml-core/src/serializer.rs:::format_scalar_to [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +1,800,700 ( 2.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::write_event:: +1,726,575 ( 2.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::write_event:: +1,433,475 ( 1.96%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs:::format_scalar_to +1,325,400 ( 1.81%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>>::write_event:: +1,187,750 ( 1.62%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] +1,175,000 ( 1.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::write_model::<&mut alloc::vec::Vec>'2 +1,150,000 ( 1.57%) crates/polyxml-core/src/serializer.rs:::validate_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +1,079,375 ( 1.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>::reserve::do_reserve_and_handle:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] +1,062,650 ( 1.45%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 916,750 ( 1.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 900,000 ( 1.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::write_model::<&mut alloc::vec::Vec>'2 + 877,975 ( 1.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 825,925 ( 1.13%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 775,225 ( 1.06%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>>::write_event:: + 651,125 ( 0.89%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 600,150 ( 0.82%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs:>>::write_event:: + 500,000 ( 0.68%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attribute::<(&str, &str)> + 466,750 ( 0.64%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 451,575 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 450,450 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 450,000 ( 0.62%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attribute::<(&str, &str)> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 450,000 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 425,425 ( 0.58%) crates/polyxml-core/src/schema.rs:::matches_variant [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 425,125 ( 0.58%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:>>::write_event:: + 425,000 ( 0.58%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attr [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 402,850 ( 0.55%) crates/polyxml-core/src/serializer.rs:::write_model::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 400,000 ( 0.55%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::push_attr + 375,000 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 351,225 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs:__rustc::__rust_realloc + 350,100 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:>>::write_event:: + 350,000 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attr + 325,000 ( 0.44%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::write_model::<&mut alloc::vec::Vec>'2 + 314,000 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 300,000 ( 0.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:>::from [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics] + 300,000 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::write_model::<&mut alloc::vec::Vec>'2 + 280,300 ( 0.38%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::format_scalar_to + 262,500 ( 0.36%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs:::format_scalar_to + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:>::reserve::do_reserve_and_handle:: + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 250,000 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 225,225 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:::matches_variant + 225,000 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::push_attr + 224,825 ( 0.31%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs:::format_scalar_to + 200,700 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_realloc + 200,000 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:::write_model::<&mut alloc::vec::Vec>'2 + 200,000 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attribute::<(&str, &str)> + 192,225 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::format_scalar_to + 175,700 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 168,725 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:::format_scalar_to + 150,525 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::reserve::do_reserve_and_handle:: + 150,000 ( 0.21%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs:::format_scalar_to + 150,000 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::write_model::<&mut alloc::vec::Vec>'2 + 150,000 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attr + 150,000 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs:::write_model::<&mut alloc::vec::Vec>'2 + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-valgrind.txt new file mode 100644 index 0000000..a780af2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000-valgrind.txt @@ -0,0 +1,12 @@ +==373380== Callgrind, a call-graph generating cache profiler +==373380== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==373380== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==373380== Command: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics write 1000 25 instructions +==373380== Parent PID: 365338 +==373380== +==373380== For interactive control, run 'callgrind_control -h'. +==373380== +==373380== Events : Ir +==373380== Collected : 73143030 +==373380== +==373380== I refs: 73,143,030 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000.callgrind new file mode 100644 index 0000000..a5286ce --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/fifo/write-1000.callgrind @@ -0,0 +1,1874 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 373380 +cmd: benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics write 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 28034902 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 73143030 + + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4126) (below main) +calls=1 0 +0 73143030 + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4162) 0x000000000002a580 +cob=(6) +cfi=(6) +cfn=(4176) main +calls=1 0 +0 73143030 + +fn=(4232) 0x00000000000b2400 +0 20825 +cfn=(4954) 0x00000000000b0f70 +calls=36 0 +0 775 +0 15950 +cfn=(4954) +calls=749 0 +0 2800 +0 2075 + +fn=(4978) 0x0000000000198400 +0 103400 + +fn=(4226) malloc +0 400 +cfn=(4232) +calls=4089 0 +0 10525 +0 650725 + +fn=(4460) 0x00000000000b4180 +0 1182900 +cfn=(4232) +calls=163 0 +0 31900 +0 1675 +cfn=(4502) 0x00000000000b2300 +calls=2112 0 +0 8425 +0 1050 +cfn=(4954) +calls=109 0 +0 1650 +0 1325 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=162 0 +0 620850 +0 600 +cfn=(4502) +calls=162 0 +0 13900 +0 200 + +fn=(4954) +0 8275 + +fn=(4128) (below main) +cfn=(4162) +calls=1 0 +0 73143030 + +fn=(4458) realloc +0 2685850 +cfn=(4460) +calls=38275 0 +0 1864475 +0 276925 + +fn=(4880) free +0 300 +cfn=(4508) 0x00000000000b20e0 +calls=4021 0 +0 3175 +0 825625 + +fn=(4502) +0 2100 +cfn=(4508) +calls=2274 0 +0 19350 +0 875 + +fn=(4508) +0 18350 +cfn=(4954) +calls=721 0 +0 3050 +0 1125 + +fn=(4488) 0x0000000000197a00 +0 4801200 + +ob=(3) +fl=(3) +fn=(4486) +0 200 +cob=(2) +cfi=(2) +cfn=(4488) +calls=213 0 +0 620650 + +ob=(6) +fl=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +fn=(5184) core::str::converts::from_utf8 +89 750125 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 450075 ++12 300050 +0 1050175 +145 250 ++19 150150 ++1 300300 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +2689 300300 +3875 150150 +fi=(39) +222 150150 ++23 250 +-21 300050 ++17 300050 +0 150025 +241 1175200 ++1 587600 +-1 1325225 +fe=(38) +94 600100 +-94 150025 +98 600100 + +fl=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(6262) quick_xml::escape::_escape::::{closure#0}, &str> +201 225000 ++3 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 25000 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +1663 25000 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 25000 +0 225000 +fi=(14) +1663 144500 +fi=(50) +385 72250 +fi=(14) +1663 144500 +fi=(50) +379 144500 +fe=(107) +169 72250 +0 144500 +218 75000 ++7 125000 ++2 225000 + +fn=(6294) quick_xml::escape::_escape::::{closure#0}, &str> +201 500000 ++3 50000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +0 250000 +180 250000 +0 150000 +fi=(14) +1663 675100 +fi=(50) +385 337550 +fi=(14) +1663 337550 +fi=(50) +180 337550 +379 675100 +fe=(107) +109 337550 +0 712650 +218 250000 ++7 200000 ++2 450000 + +fl=(100) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +fn=(6248) ::push_attribute::<(&str, &str)> +256 175000 +fi=(101) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs ++28 75000 +fi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +611 25000 +fi=(126) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/char/methods.rs +2558 25000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1440 25000 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +2224 75000 +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs +781 50000 +cfi=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +cfn=(6260) >::from +calls=36000 376 +* 2097500 +fe=(100) +261 75000 +cfn=(6270) ::push_attr +calls=36000 +41 +* 5899500 ++1 200000 +fi=(101) ++23 50000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +478 25000 +fi=(32) +0 25000 +461 25000 +0 100000 +cfi=(6) +cfn=(5102) __rustc::__rust_no_alloc_shim_is_unstable_v2 +calls=36000 0 +0 25000 +0 25000 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +130 75000 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/candidate/src/main.rs +cfn=(5104) __rustc::__rust_alloc +calls=36000 -89 +* 950000 +fi=(32) +470 50000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +0 25000 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 375000 +* 50000 +fi=(101) +286 75000 +fi=(32) +672 175000 +cfn=(5534) >::reserve::do_reserve_and_handle:: +calls=36000 -14 +* 5375000 +* 75000 +fe=(100) + +fn=(6270) +302 225000 +fi=(101) +-18 75000 +fi=(33) +1461 50000 +fi=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +222 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +0 25000 +fi=(20) +970 25000 +fi=(18) +573 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 450000 +fi=(33) +2986 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +-59 25000 +fi=(18) +-38 25000 +fi=(33) +2986 50000 +fi=(101) +0 75000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +fi=(20) +970 50000 +fi=(18) +573 50000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 449500 +fi=(33) +2986 50000 +fi=(32) +764 25000 +-94 25000 +fi=(126) +2558 25000 +fi=(40) +1440 25000 +fi=(33) +2224 25000 +fi=(18) +847 75000 +fe=(100) +309 200000 +fi=(32) +672 100000 +cfn=(5534) +calls=36000 -14 +* 3125000 +-56 25000 +fi=(33) +3101 50000 +fe=(100) + +fl=(111) /home/bailey/github/PolyXML/crates/polyxml-core/src/lib.rs +fn=(6158) polyxml::serialize +40 50 +fi=(120) /home/bailey/github/PolyXML/crates/polyxml-core/src/serializer.rs +180 125 +cfn=(6160) ::serialize_with_options +calls=36 +3 +* 73138025 +* 25 +fe=(111) +47 75 + +fl=(6) +fn=(4126) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 73143030 + +fn=(4176) +cfi=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +cfn=(4178) std::rt::lang_start_internal +calls=1 152 +0 73143030 + +fn=(5102) +0 25025 + +fl=(120) +fn=(6160) +183 350 +cfi=(6) +cfn=(5102) +calls=36 0 +* 25 +fi=(23) +-53 75 +cfi=(24) +cfn=(5104) +calls=36 -89 +* 11950 +fi=(32) +470 50 +fi=(33) +969 75 +fe=(120) +192 50 +fi=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +0 25 +743 25 +0 25 +fi=(122) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs +124 75 +fe=(120) ++73 50 +0 50 +199 75 +cfn=(6170) ::build +calls=36 22 +* 7000 +fi=(41) +743 75 +0 25 +743 75 +0 50 +fe=(120) +202 225 +cfn=(6198) ::write_model::<&mut alloc::vec::Vec> +calls=36 302 +* 73117100 +* 25 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +2177 50 +fe=(120) +212 150 +fi=(18) +847 125 +fe=(120) +0 25 +213 200 + +fn=(6288) ::validate_scalar +285 200000 ++10 50000 +-9 150000 ++9 200000 +-9 350000 ++13 50000 ++1 150000 + +fn=(6170) +22 250 +fi=(33) +462 100 +fe=(120) +27 50 +cfn=(6172) ::collect_namespaces +calls=36 +60 +* 6150 +fi=(33) +3126 25 +fe=(120) +29 25 +fi=(41) +709 50 +fe=(120) +0 25 +30 25 +fi=(32) +425 50 +631 25 +fe=(120) +85 225 + +fn=(6198) +302 250 ++9 125 +0 50 +324 75 +0 25 +fi=(14) +454 25 +fi=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2454 75 +fe=(120) +325 75 +cfi=(45) /home/bailey/github/PolyXML/crates/polyxml-core/src/schema.rs +cfn=(6200) ::matches_variant +calls=36 182 +* 950 +* 50 +fi=(50) +0 75 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 575 +fi=(41) +634 50 +fe=(120) +353 50 +0 25 +251 350 ++2 50 +-2 50 +fi=(27) +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25 +fi=(41) +634 50 +fe=(120) +361 25 +fi=(23) +0 75 +fe=(120) +409 25 +cfi=(38) +cfn=(5184) +calls=36 89 +* 2600 +fi=(27) +0 50 +2177 50 +fi=(111) +0 25 +fe=(120) +410 50 ++3 75 +fi=(100) +124 100 +0 25 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 500 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +434 125 ++33 50 ++21 200 +cfi=(122) +cfn=(6218) >>::write_event:: +calls=36 262 +* 2050 +* 25 +0 25 +fi=(27) +965 50 +fi=(111) +0 25 +fe=(120) +492 50 ++30 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 475 +fe=(120) +616 125 +345 50 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +184 50 ++2 50 +fi=(41) +743 50 +0 50 +fi=(129) /home/bailey/github/PolyXML/crates/polyxml-core/src/value.rs +59 25 +fe=(120) +618 25 +fi=(41) +743 75 +fi=(27) +0 25 +fi=(41) +743 50 +fe=(120) +624 225 +0 25 +656 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25075 +fi=(14) +1663 25000 +fi=(50) +180 25000 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +2415 25000 +fe=(120) +658 175000 +fi=(41) ++85 50000 +fi=(14) +454 25000 +fi=(41) +743 50000 +fi=(23) +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fi=(59) +2454 25000 +fe=(120) +714 200000 +cfn=(6199) ::write_model::<&mut alloc::vec::Vec>'2 +calls=36000 302 +* 72328100 +* 25000 +fi=(27) +2177 50000 +fe=(120) +0 25 +fi=(41) +743 25 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +fi=(101) +350 50 +fe=(120) +756 175 +cfi=(122) +cfn=(6218) +calls=36 262 +* 2025 +fi=(27) +965 50 +fe=(120) +760 200 +0 25 +759 25 ++1 25 +fi=(18) ++87 50 +fi=(23) +0 25 +fi=(18) +847 75 +fe=(120) + +fn=(6199) +302 250000 ++9 125000 +0 50000 +324 75000 +0 25000 +fi=(14) +454 25000 +fi=(59) +2454 75000 +fe=(120) +325 75000 +cfi=(45) +cfn=(6200) +calls=36000 182 +* 950000 +* 50000 +fi=(50) +0 75000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 575000 +fi=(41) +634 150000 +fe=(120) +353 150000 +0 75000 +251 750000 +353 150000 +fi=(27) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +0 25000 +fi=(41) +634 50000 +fe=(120) +361 25000 +fi=(23) +0 75000 +fe=(120) +409 25000 +cfi=(38) +cfn=(5184) +calls=36000 89 +* 1475000 +fi=(27) +0 50000 +2177 50000 +fi=(111) +0 25000 +fe=(120) +410 50000 ++3 75000 +fi=(100) +124 100000 +0 25000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 550000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 100000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +fe=(120) +434 375000 +0 25000 +345 50000 +fi=(44) +184 50000 ++2 50000 +fi=(41) +743 50000 +0 50000 +fi=(129) +59 25000 +fe=(120) +436 25000 +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(120) +437 50000 +cfi=(38) +cfn=(5184) +calls=36000 89 +* 1225000 +fi=(27) +0 50000 +2177 50000 +0 25000 +fe=(120) +410 25000 ++28 25000 ++3 75000 +-3 25000 +0 25000 +443 100000 ++1 100000 +cfn=(6236) ::format_scalar_to +calls=36000 216 +* 2805750 +* 125000 +295 25000 +-9 100000 +445 50000 +295 150000 +-9 75000 +fi=(101) ++64 25000 +fe=(120) ++96 175000 +cfi=(100) +cfn=(6248) +calls=36000 256 +* 16322000 +fi=(18) +847 125000 +fe=(120) +286 125000 +467 50000 ++21 200000 +cfi=(122) +cfn=(6218) +calls=36000 262 +* 2944050 +* 25000 +0 25000 +fi=(27) +965 50000 +fi=(111) +0 25000 +fe=(120) +492 50000 ++30 50000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 475000 +fe=(120) +616 375000 +345 100000 +fi=(44) +184 100000 ++2 100000 +fi=(41) +743 100000 +0 100000 +fi=(129) +59 50000 +fe=(120) +618 50000 +fi=(41) +743 150000 +fi=(27) +0 50000 +fi=(41) +743 100000 +fe=(120) +624 450000 +fi=(41) +0 100000 +fe=(120) +626 200000 ++1 200000 +cfn=(6236) +calls=72000 216 +* 8087575 +* 150000 +0 100000 +627 100000 +fi=(32) +-16 50000 +fi=(33) +1865 50000 +fe=(120) +628 250000 +cfn=(6288) +calls=72000 285 +* 1150000 +fi=(27) +2177 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(120) +629 100000 +cfi=(38) +cfn=(5184) +calls=72000 89 +* 3075000 +fi=(27) +0 100000 +2177 100000 +0 50000 +fe=(120) +410 50000 +630 50000 +0 50000 +fi=(41) +743 50000 +fi=(33) +0 50000 +fe=(120) +633 150000 ++4 400000 +cfi=(122) +cfn=(6218) +calls=72000 262 +* 4121050 +fi=(27) +965 100000 +fi=(107) +108 200000 +cfn=(6294) +calls=72000 +93 +* 5613050 +fi=(100) +564 250000 +fe=(120) ++80 200000 +cfi=(122) +cfn=(6218) +calls=72000 262 +* 3765775 +fi=(27) +965 100000 +fe=(120) +649 350000 +cfi=(122) +cfn=(6218) +calls=72000 262 +* 4068850 +fi=(27) +965 100000 +fe=(120) +653 50000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 100000 +fi=(118) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fi=(101) +350 50000 +fe=(120) +756 175000 +cfi=(122) +cfn=(6218) +calls=36000 262 +* 2025000 +fi=(27) +965 50000 +fe=(120) +760 200000 +0 25000 +759 25000 ++1 25000 +fi=(18) ++87 50000 +fi=(23) +0 25000 +fi=(18) +847 75000 +fe=(120) + +fn=(6236) +216 600000 ++4 300000 +0 75000 +220 225000 ++7 25000 +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/f64.rs +1264 25000 +886 100000 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +1037 50000 +fi=(32) +611 50000 +fe=(120) +223 25000 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2144 25000 +fi=(144) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/api.rs +50 25000 +fi=(123) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs +310 50000 ++2 50000 +118 22500 ++2 45000 ++1 45000 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +-60 22500 +fi=(123) ++16 22500 +-39 45000 ++76 67500 +fi=(44) +219 22500 +fi=(123) +68 22500 ++20 22500 ++1 22500 +-21 22500 ++21 45000 +314 22500 +0 125000 +fi=(128) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/bit.rs +178 50000 +fi=(19) +2105 25000 +fi=(125) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs +121 25000 +fi=(10) +0 25000 +fi=(127) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs +292 50025 +0 50 +fi=(128) +282 50 +fi=(10) +154 25 +fi=(145) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/decimal.rs +32 50 +fi=(44) +186 25 +fi=(19) +2150 25 +fi=(145) +108 25 +fi=(127) +-54 25 +fi=(146) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs +181 100 +fi=(128) +282 49950 +fi=(10) +154 24975 +fi=(145) +32 49950 +fi=(44) +186 24975 +fi=(19) +2150 24975 +fi=(145) +108 24975 +fi=(127) +-54 24975 +fi=(146) +181 99900 +fi=(123) +0 25000 +fi=(146) +186 50000 +fi=(127) +53 50000 +fi=(123) +310 50000 ++2 24500 +118 9375 ++2 18750 ++1 28125 +fi=(124) +-60 3350 +fi=(123) ++16 3350 +-39 6700 ++76 10050 +fi=(44) +219 3350 +fi=(123) +68 3350 ++20 3350 ++1 3350 +-21 3350 ++21 6700 +fi=(127) +225 3350 ++3 9500 +fi=(44) +0 99900 +fi=(127) +352 24975 +0 49950 +fi=(128) +178 24975 +fi=(115) +1057 74925 +fi=(19) +2105 24975 +fi=(115) +1057 99900 +fi=(147) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 24975 +fi=(127) +875 24975 +456 49950 +fi=(44) +219 24975 +fi=(147) +2261 24975 +fi=(44) +219 49950 +fi=(148) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/index.rs +13 24975 +fi=(127) +883 24975 +457 24975 +1381 149850 +fi=(148) +13 24975 +fi=(127) +461 49950 ++12 74925 +836 99900 +-6 74925 ++7 49950 +-7 99900 +968 24975 +fi=(10) +2728 24975 +fi=(127) +484 24975 ++13 49950 +-51 24975 ++54 24975 +fi=(123) +314 5000 +fi=(44) +-95 2250 +fi=(123) +68 2250 ++20 4500 +fe=(120) +-88 12750 +fi=(123) +319 38250 ++2 25500 +fi=(124) +61 250 +fi=(123) ++16 500 +314 250 +0 4500 +314 8625 +fi=(44) +-95 2350 +fi=(123) +68 4700 ++20 2350 ++1 4700 +fi=(127) +225 2350 ++3 7000 +fi=(44) +-9 6025 +fi=(123) +68 12050 ++20 6025 ++1 6025 +-51 12050 ++76 18075 +-46 6025 ++20 6025 ++1 6025 +-21 6025 ++21 12050 +fi=(127) +225 6025 ++3 12675 +fi=(123) ++98 25500 +fi=(124) +61 525 +fi=(123) ++16 525 +fi=(127) +225 1575 +0 24975 +1398 74925 +535 24975 +1404 149850 ++2 124875 +0 24975 +fi=(10) +2728 24975 +fi=(127) +1088 24975 +1412 74925 +0 36050 +fi=(10) +2728 36050 +fi=(127) +1088 36050 +1412 108150 +fi=(10) +2728 24975 +fi=(127) +1088 24975 +1421 124875 +-32 49950 +fi=(123) +328 38250 +118 12750 ++2 25500 ++1 25500 +fi=(124) +-60 10250 +fi=(123) ++16 10250 +-39 30750 ++76 30750 +fi=(44) +219 10250 +fi=(123) +68 10250 ++20 10250 ++1 10250 +-21 10250 ++21 10250 +-51 10250 ++76 30750 +-46 10250 ++20 10250 ++1 10250 +-21 10250 ++21 20500 +fi=(127) +225 10250 ++3 20500 ++19 37500 +fi=(44) +102 18750 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1142 37500 +0 18750 +1142 18750 +fi=(19) +2144 18750 +0 18750 +2144 18750 +fi=(127) +251 56250 +fi=(34) +1142 18750 +fi=(19) +2144 12500 +fi=(127) +251 37500 +fi=(34) +1142 12500 +fi=(127) +248 18750 ++7 18750 +fi=(125) +154 18750 +fi=(10) +1092 18750 +fi=(44) +219 2500 +fi=(123) +68 5000 ++20 2500 ++1 2500 +-51 7500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 2500 +-51 2500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 5000 +fi=(127) +225 2500 ++3 5000 +fi=(10) +1096 12500 +fi=(44) +102 12500 +fi=(149) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/specialize.rs +-68 18750 +cob=(2) +cfi=(2) +cfn=(4978) +calls=9000 -34 +* 103400 +fi=(127) +236 6250 ++3 6250 +fi=(125) +-85 12500 +0 31250 +cfi=(38) +cfn=(5184) +calls=9000 89 +0 403500 +0 175000 +cfi=(38) +cfn=(5184) +calls=63000 89 +0 2609250 +fi=(27) +714 100000 ++1 50000 +fe=(120) +0 100000 +234 400000 +0 50000 +234 200000 + +fn=(6172) +87 225 ++1 100 +fi=(33) +-88 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fi=(14) +454 25 +fi=(59) +2454 50 +fe=(120) +0 25 +cfn=(6173) ::collect_namespaces'2 +calls=36 87 +0 3225 +0 25 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +-86 50 ++5 225 +fi=(28) +2415 25 +fe=(120) +102 75 +fi=(14) +454 25 +fe=(120) +102 25 +0 25 +109 50 +0 50 +125 25 +cfi=(45) +cfn=(6182) ::variants +calls=36 +18 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +126 25 +fi=(32) +425 50 +631 25 +fe=(120) +134 200 + +fn=(6173) +87 225 ++1 100 +fi=(33) +-88 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fe=(120) +0 75 +fi=(14) +1663 75 +fi=(50) +180 75 +fe=(120) +-86 150 ++5 525 +-99 25 +109 50 +0 50 +125 25 +cfi=(45) +cfn=(6182) +calls=36 +18 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +126 25 +fi=(32) +425 50 +631 25 +fe=(120) +134 200 + +fl=(94) +fn=(6260) +376 75000 ++2 50000 ++1 50000 +fi=(107) +168 50000 +cfn=(6262) +calls=36000 +33 +* 1722500 +* 25000 +fe=(94) +377 25000 ++4 100000 + +fl=(8) +fn=(5138) std::rt::lang_start::<()>::{closure#0} +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5140) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 73143030 + +fn=(4178) +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5138) +calls=1 206 +287 73143030 +fe=(8) + +fl=(45) +fn=(6200) +182 200200 +fi=(14) +454 25025 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 25025 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) +180 25025 +0 75075 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fe=(45) ++73 225225 + +fn=(6182) +143 350 +fi=(14) +454 50 +fi=(59) +2454 50 +fi=(13) +3994 50 +fi=(97) +54 100 ++45 50 +fi=(13) +4149 50 +fi=(97) +97 50 +fi=(13) +3994 50 +fi=(33) +1865 50 +fi=(10) +3212 350 +fi=(47) +478 100 +fi=(32) +-17 100 +fi=(121) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/take.rs +0 50 +fi=(36) +440 200 +fi=(13) +4049 50 +fi=(97) +111 50 ++7 200 +fe=(45) ++30 450 + +fl=(30) +fn=(5140) +fi=(150) +cfi=(24) +cfn=(5142) xml_diagnostics::main +calls=1 43 +250 73143030 +fe=(30) + +fl=(122) +fn=(6218) +262 1600400 +fi=(142) +792 600150 +fe=(122) +264 600150 ++1 300100 ++53 75025 +0 75025 +318 75025 +-31 150000 ++26 50000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99850 +0 50000 +fi=(20) +970 50000 +fi=(18) +573 150000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=72000 0 +* 705300 +fi=(33) +2986 100000 +fe=(122) +0 250000 +272 300100 +fi=(41) +765 150050 +fi=(33) +1461 75025 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(32) +616 75025 +fi=(10) +2689 150050 +fi=(32) +764 75025 +-94 75025 +fi=(33) +2981 149900 +0 75025 +fi=(20) +970 150050 +fi=(18) +573 150050 +cob=(2) +cfi=(2) +cfn=(4488) +calls=108036 0 +* 1075375 +fi=(32) ++43 75025 +fi=(33) +2986 150050 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(41) +765 225075 +fi=(18) ++82 275100 +fe=(122) +0 75025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(32) +616 75025 +fi=(10) +2689 150050 +fi=(32) +764 75025 +-94 75025 +fi=(33) +2981 150050 +0 75025 +fi=(20) +970 150050 +fi=(18) +573 150050 +cob=(2) +cfi=(2) +cfn=(4488) +calls=108036 0 +* 1125375 +fi=(32) ++43 75025 +fi=(33) +2986 150050 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(18) +847 300100 +fe=(122) +0 100000 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5686) __rustc::__rust_dealloc +calls=36000 65 +0 850000 +fi=(41) +765 400100 +fe=(122) +308 1800450 +fi=(32) +672 450 +cfn=(5534) +calls=108 -14 +* 660025 +fi=(33) +3101 75 +2981 75 +fi=(32) +672 150 +cfn=(5534) +calls=36 -14 +* 18650 +fi=(33) +3101 50 +0 75 +fi=(32) +672 450 +cfn=(5534) +calls=108 -14 +* 39500 +fi=(33) +3101 150 +2981 75 +fe=(122) + +fl=(32) +fn=(5232) ::finish_grow +544 201400 +fi=(10) +3212 201400 +fi=(47) +478 75525 +0 25175 +fe=(32) +631 25175 +fi=(10) +1401 25175 +fi=(23) +228 125875 +cfi=(24) +cfn=(5542) __rustc::__rust_realloc +calls=36276 41 +* 4179875 +fi=(27) +965 50350 ++1 75525 +fe=(32) +0 50350 +564 151050 +-20 200000 +fi=(10) +3212 200000 +fi=(47) +478 75000 +fe=(32) +631 50000 +fi=(10) +1401 25000 +fi=(23) +228 125000 +cfi=(24) +cfn=(5542) +calls=36002 41 +* 1400000 +fi=(27) +965 50000 ++1 75000 +fe=(32) +0 50000 +564 150000 + +fn=(5534) +658 100700 +512 50350 +fi=(10) +938 25175 +fi=(47) +478 25175 +0 25175 +fe=(32) +523 50350 +fi=(19) +1051 50350 +fe=(32) +159 176225 +fi=(19) +1051 75525 +fe=(32) +529 100700 +cfn=(5232) +calls=36258 +15 +* 5186875 +fi=(27) +2177 50350 ++1 25175 +fe=(32) +773 25175 ++1 25175 +668 100700 +-10 75000 +fi=(10) +938 25000 +fi=(47) +478 25000 +0 25000 +fe=(32) +523 50000 +fi=(19) +1051 125000 +fe=(32) +529 175000 +cfn=(5232) +calls=36004 +15 +* 2400000 +fi=(27) +2177 50000 ++1 25000 +fe=(32) +773 25000 ++1 25000 +668 100000 + +fl=(26) +fn=(5686) +65 25000 +cob=(2) +cfi=(2) +cfn=(4880) +calls=42043 -65 +* 825000 + +fl=(24) +fn=(5142) +cfn=(6416) measured_region +calls=1 79 +70 73143030 + +fn=(6416) +79 9 +fi=(19) +2144 1 +fi=(34) +1100 1 +0 8 +fi=(26) +0 3 +fi=(19) +2144 25 +fi=(34) +1100 25 +fi=(131) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 50 +fe=(24) +91 175 +cfi=(111) +cfn=(6158) +calls=25 -51 +* 73138300 +fi=(27) +1230 50 ++1 100 +fi=(131) +491 50 +fi=(32) +631 50 +425 25 +fi=(26) +65 25 +cob=(2) +cfi=(2) +cfn=(4880) +calls=25 -65 +* 4100 +* 25 +fe=(24) ++29 8 + +fn=(5104) +41 25025 +fi=(13) +3994 25025 +762 25025 +fe=(24) +16 25025 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 100100 +fi=(26) +30 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4226) +calls=46080 -31 +* 661650 +fe=(24) + +fn=(5542) +41 50175 +fi=(13) +3994 50175 +762 50175 +fe=(24) +33 50175 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 250875 +405 100350 +fi=(26) +70 100350 ++1 100350 +cob=(2) +cfi=(2) +cfn=(4458) +calls=72278 -71 +* 4827250 +fe=(24) + +totals: 73143030 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-Cargo.toml b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-Cargo.toml new file mode 100644 index 0000000..90ec6de --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-Cargo.toml @@ -0,0 +1,9 @@ +[package] +name="xml-diagnostics" +version="0.0.0" +edition="2021" +[workspace] +[dependencies] +polyxml={path="/home/bailey/github/polyxml-perf-old/crates/polyxml-core"} +[profile.release] +debug=1 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-allocations.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-allocations.txt new file mode 100644 index 0000000..8c48158 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-allocations.txt @@ -0,0 +1,12 @@ +memcap: <=7726 MiB (60% of 12877 MiB available) [systemd MemoryMax, swap off] +operation=read,count=0,iterations=1,allocations=12,reallocations=5,requested_bytes=10325,input_bytes=94,output_bytes=94,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 +memcap: <=7738 MiB (60% of 12897 MiB available) [systemd MemoryMax, swap off] +operation=write,count=0,iterations=1,allocations=2,reallocations=2,requested_bytes=554,input_bytes=94,output_bytes=94,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 +memcap: <=7738 MiB (60% of 12897 MiB available) [systemd MemoryMax, swap off] +operation=read,count=1000,iterations=1,allocations=5010,reallocations=1014,requested_bytes=716634,input_bytes=63911,output_bytes=63411,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 +memcap: <=7738 MiB (60% of 12897 MiB available) [systemd MemoryMax, swap off] +operation=write,count=1000,iterations=1,allocations=1001,reallocations=2007,requested_bytes=158560,input_bytes=63911,output_bytes=63411,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 +memcap: <=7738 MiB (60% of 12897 MiB available) [systemd MemoryMax, swap off] +operation=read,count=10000,iterations=1,allocations=50010,reallocations=10019,requested_bytes=7773970,input_bytes=668911,output_bytes=663911,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 +memcap: <=7735 MiB (60% of 12892 MiB available) [systemd MemoryMax, swap off] +operation=write,count=10000,iterations=1,allocations=10001,reallocations=20011,requested_bytes=2376640,input_bytes=668911,output_bytes=663911,field_schema_bytes=96,scalar_type_bytes=1,value_type_bytes=16,poly_value_bytes=56 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-build.txt new file mode 100644 index 0000000..d786899 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-build.txt @@ -0,0 +1,35 @@ +memcap: <=7793 MiB (60% of 12989 MiB available) [systemd MemoryMax, swap off] + Locking 1 package to highest compatible version + Downgrading polyxml v0.34.6 (/home/bailey/github/polyxml-perf-old/crates/polyxml-core) -> v0.27.0 + Compiling proc-macro2 v1.0.107 + Compiling unicode-ident v1.0.26 + Compiling quote v1.0.47 + Compiling syn v3.0.6 + Compiling serde_core v1.0.229 + Compiling lexical-util v1.0.7 + Compiling serde v1.0.229 + Compiling serde_derive v1.0.229 + Compiling siphasher v1.0.4 + Compiling zmij v1.0.23 + Compiling phf_shared v0.14.0 + Compiling lexical-parse-integer v1.0.6 + Compiling lexical-write-integer v1.0.6 + Compiling memchr v2.8.3 + Compiling serde_json v1.0.151 + Compiling fastrand v2.5.0 + Compiling thiserror v2.0.21 + Compiling phf_generator v0.14.0 + Compiling lexical-write-float v1.0.6 + Compiling lexical-parse-float v1.0.6 + Compiling thiserror-impl v2.0.21 + Compiling memo-map v0.3.4 + Compiling itoa v1.0.18 + Compiling minijinja v2.24.0 + Compiling lexical-core v1.0.6 + Compiling phf_codegen v0.14.0 + Compiling quick-xml v0.42.0 + Compiling heck v0.5.0 + Compiling smallvec v1.16.2 + Compiling polyxml v0.27.0 (/home/bailey/github/polyxml-perf-old/crates/polyxml-core) + Compiling xml-diagnostics v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old) + Finished `release` profile [optimized + debuginfo] target(s) in 44.28s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-fixtures.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-fixtures.rs new file mode 100644 index 0000000..f231439 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-fixtures.rs @@ -0,0 +1,85 @@ +use std::hint::black_box; + +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + (catalog_schema, xml.into_bytes()) +} + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-harness.rs new file mode 100644 index 0000000..1fbe95d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-harness.rs @@ -0,0 +1,94 @@ +// Fixture definitions are extracted verbatim from core_benchmarks.rs by run.py. +include!("fixtures.rs"); + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +struct CountingAllocator; +static COUNTING: AtomicBool = AtomicBool::new(false); +static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static REALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static BYTES: AtomicUsize = AtomicUsize::new(0); + +// Diagnostic instrumentation only. The benchmark consumers use System directly. +unsafe impl GlobalAlloc for CountingAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc(layout) } + } + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc_zeroed(layout) } + } + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + REALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(new_size, Ordering::Relaxed); + } + unsafe { System.realloc(ptr, layout, new_size) } + } +} +#[global_allocator] +static ALLOCATOR: CountingAllocator = CountingAllocator; + +fn main() { + let args: Vec = std::env::args().collect(); + let operation = args.get(1).expect("read or write"); + let count: usize = args + .get(2) + .expect("0 for sensor, or catalog count") + .parse() + .unwrap(); + let iterations: usize = args.get(3).expect("iteration count").parse().unwrap(); + let mode = args.get(4).map(String::as_str).unwrap_or("allocations"); + let (schema, xml) = if count == 0 { + build_sensor_fixture() + } else { + build_catalog_fixture(count) + }; + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let root = if count == 0 { "Sensor" } else { "Catalog" }; + let output = serialize(root, &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + for _ in 0..10 { + if operation == "read" { + black_box(deserialize(&xml, Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize(root, &value, &schema, None).unwrap()); + } + } + COUNTING.store(mode == "allocations", Ordering::Relaxed); + measured_region(operation, iterations, &xml, &value, root, &schema); + COUNTING.store(false, Ordering::Relaxed); + println!("operation={operation},count={count},iterations={iterations},allocations={},reallocations={},requested_bytes={},input_bytes={},output_bytes={},field_schema_bytes={},scalar_type_bytes={},value_type_bytes={},poly_value_bytes={}", + ALLOCATIONS.load(Ordering::Relaxed), REALLOCATIONS.load(Ordering::Relaxed), BYTES.load(Ordering::Relaxed), xml.len(), output.len(), + std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::()); +} + +#[inline(never)] +#[no_mangle] +fn measured_region( + operation: &str, + iterations: usize, + xml: &[u8], + value: &polyxml::PolyValue, + root: &str, + schema: &Arc, +) { + for _ in 0..iterations { + if operation == "read" { + black_box(deserialize(black_box(xml), Arc::clone(schema)).unwrap()); + } else { + black_box(serialize(root, black_box(value), schema, None).unwrap()); + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-metadata.json new file mode 100644 index 0000000..8f886bf --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old-metadata.json @@ -0,0 +1,5 @@ +{ + "revision": "cef575c11cc4f05e877ced157036f7ff53b8687b", + "executable": "/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics", + "profile": "release debug=1; allocation instrumentation; not used for latency numbers" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old.lock new file mode 100644 index 0000000..f67463f --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/old.lock @@ -0,0 +1,278 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.27.0" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-diagnostics" +version = "0.0.0" +dependencies = [ + "polyxml", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-annotated.txt new file mode 100644 index 0000000..c35febb --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-annotated.txt @@ -0,0 +1,191 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/old/read-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 86391197 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics read 1000 25 instructions (PID 341913, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +283,054,621 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +21,680,675 ( 7.66%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +13,926,225 ( 4.92%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +11,866,582 ( 4.19%) ???:0x00000000000b2400 [/usr/lib/x86_64-linux-gnu/libc.so.6] +10,868,100 ( 3.84%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +10,402,925 ( 3.68%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 8,900,000 ( 3.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs: as core::hash::Hasher>::write [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 7,927,350 ( 2.80%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:::deserialize_with_limit [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 7,802,014 ( 2.76%) ???:0x00000000000b20e0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 6,602,200 ( 2.33%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 5,426,700 ( 1.92%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs:::feed [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 5,127,950 ( 1.81%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,625,000 ( 1.63%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs:::hash_one::<&[u8]> + 4,403,350 ( 1.56%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,225,800 ( 1.49%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:> as core::iter::traits::iterator::Iterator>::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 4,001,000 ( 1.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 3,800,475 ( 1.34%) ???:0x00000000001972a0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 3,200,000 ( 1.13%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:polyxml::parser::is_nil_element [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 3,176,250 ( 1.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::deserialize_with_limit + 3,175,500 ( 1.12%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:> as core::iter::traits::iterator::Iterator>::next + 3,150,700 ( 1.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 3,001,875 ( 1.06%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 3,000,000 ( 1.06%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::hash_one::<&[u8]> + 2,875,600 ( 1.02%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,825,875 ( 1.00%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:polyxml::parser::namespace_scope [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,800,000 ( 0.99%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::deserialize_with_limit + 2,625,750 ( 0.93%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,425,000 ( 0.86%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/converters.rs:::parse_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,415,742 ( 0.85%) ???:0x00000000000b0f70 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 2,375,000 ( 0.84%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::hash_one::<&[u8]> + 2,325,000 ( 0.82%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::check_for_duplicates [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,250,000 ( 0.79%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:> as core::iter::traits::iterator::Iterator>::next + 2,076,050 ( 0.73%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_start + 2,025,675 ( 0.72%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_end [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 2,025,675 ( 0.72%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_start [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,950,800 ( 0.69%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,948,250 ( 0.69%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,900,350 ( 0.67%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::next + 1,850,875 ( 0.65%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:::parse_attributes [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,558,400 ( 0.55%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs:::parse_scalar + 1,500,300 ( 0.53%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:> as core::iter::traits::iterator::Iterator>::next + 1,500,150 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 1,500,000 ( 0.53%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs:::hash_one::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,489,425 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,465,250 ( 0.52%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,366,800 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::next + 1,357,775 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,350,000 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::grow_one [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 1,300,275 ( 0.46%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,275,425 ( 0.45%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs:::emit_end + 1,250,450 ( 0.44%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:; 8]>>::from_elem + 1,200,400 ( 0.42%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,199,850 ( 0.42%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 1,175,000 ( 0.42%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::deserialize_with_limit + 1,150,300 ( 0.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:::feed + 1,075,300 ( 0.38%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 1,050,400 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,050,300 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:::feed + 1,050,300 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_end + 1,050,150 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::deserialize_with_limit + 1,000,000 ( 0.35%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::deserialize_with_limit + 1,000,000 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::deserialize_with_limit + 975,000 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 950,450 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs:::deserialize_with_limit + 950,100 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::next + 901,650 ( 0.32%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:::finish [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 900,525 ( 0.32%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 900,300 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 900,275 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_end + 900,100 ( 0.32%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 850,150 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 850,000 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::local_name [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 850,000 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::local_name + 801,000 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::deserialize_with_limit + 800,575 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_start + 800,200 ( 0.28%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:::deserialize_with_limit + 750,250 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 750,250 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_start + 750,000 ( 0.26%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::next + 750,000 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs: as core::hash::Hasher>::write + 750,000 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs:::hash_one::<&[u8]> + 725,725 ( 0.26%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]>>::from_elem [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 725,000 ( 0.26%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:::deserialize_with_limit + 700,250 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 700,100 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_scalar + 700,000 ( 0.25%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:::new [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 675,675 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 675,225 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_start + 675,150 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 675,000 ( 0.24%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::unescape [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 675,000 ( 0.24%) /rust/deps/hashbrown-0.17.1/src/map.rs:::deserialize_with_limit + 625,000 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs:::parse_scalar + 603,525 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 600,600 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,200 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,150 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:core::ptr::drop_glue::> + 600,000 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 575,250 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::deserialize_with_limit + 550,550 ( 0.19%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:polyxml::parser::resolve_record_schema [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 525,200 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs:::deserialize_with_limit + 525,175 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_end + 525,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::check_for_duplicates + 525,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::check_for_duplicates + 501,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs:__rustc::__rust_alloc + 501,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_alloc + 500,000 ( 0.18%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs:::try_fast_path:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 500,000 ( 0.18%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_text [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 500,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::hash::Hasher>::write + 480,650 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::parse_scalar + 475,475 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:>; 4]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 475,475 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 466,875 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 452,375 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 451,150 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::finish + 450,425 ( 0.16%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs:::push_list_item [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 450,150 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_end + 450,150 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 450,150 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 450,150 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::emit_start + 450,100 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs:::parse_scalar + 450,050 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 450,000 ( 0.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_attributes + 425,850 ( 0.15%) ???:0x00000000000b2300 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 425,000 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::parse_scalar + 422,350 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 419,500 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs:::parse_scalar + 400,400 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 400,300 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,125 ( 0.14%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,100 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 400,100 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::feed + 400,000 ( 0.14%) /rust/deps/hashbrown-0.17.1/src/lib.rs:::deserialize_with_limit + 377,250 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 375,425 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_start + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::emit_start + 375,075 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::deserialize_with_limit + 350,100 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::feed + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::push_mut [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::hash::Hasher>::write + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 325,075 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::deserialize_with_limit + 300,300 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::into_boxed_slice [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 300,100 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 300,100 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,075 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::namespace_scope + 300,050 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,050 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::emit_end + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs:::deserialize_with_limit + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::is_nil_element + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:> as core::iter::traits::iterator::Iterator>::next + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::check_for_duplicates + 300,000 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::deserialize_with_limit + 291,750 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs:::next + 275,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs:::parse_scalar + 275,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::deserialize_with_limit + 275,000 ( 0.10%) /rust/deps/hashbrown-0.17.1/src/control/tag.rs:::deserialize_with_limit + 275,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::deserialize_with_limit + 275,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs:::deserialize_with_limit + 250,500 ( 0.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:__rustc::__rust_alloc + 250,500 ( 0.09%) benchmarks/rust-runtime-investigation/target/old/src/main.rs:__rustc::__rust_alloc [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 250,100 ( 0.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::deserialize_with_limit + 250,000 ( 0.09%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::parse_attributes + 226,525 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 225,225 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:polyxml::parser::resolve_record_schema + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-valgrind.txt new file mode 100644 index 0000000..ad5cc3e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-valgrind.txt @@ -0,0 +1,12 @@ +==341913== Callgrind, a call-graph generating cache profiler +==341913== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==341913== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==341913== Command: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics read 1000 25 instructions +==341913== Parent PID: 341905 +==341913== +==341913== For interactive control, run 'callgrind_control -h'. +==341913== +==341913== Events : Ir +==341913== Collected : 283054621 +==341913== +==341913== I refs: 283,054,621 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000.callgrind new file mode 100644 index 0000000..0e6f629 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/read-1000.callgrind @@ -0,0 +1,3453 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 341913 +cmd: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics read 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 86391197 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 283054621 + + +ob=(3) ??? +fl=(3) ??? +fn=(4488) 0x000000000495a6a0 +0 50 +cob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +cfi=(2) ??? +cfn=(4490) 0x0000000000197a00 +calls=110 0 +0 275 + +ob=(2) +fl=(2) +fn=(4130) (below main) +cfn=(4164) 0x000000000002a580 +calls=1 0 +0 283054621 + +fn=(4510) 0x00000000000b20e0 +0 4946901 +cfn=(4952) 0x00000000000b0f70 +calls=73348 0 +0 1088042 +0 2455988 +cfn=(4952) +calls=34982 0 +0 548077 +0 399125 + +fn=(4332) 0x00000000000b08d0 +0 120375 + +fn=(4490) +0 21680675 + +fn=(4234) 0x00000000000b2400 +0 10560889 +cfn=(4952) +calls=35804 0 +0 779623 +0 1275170 +cfn=(4332) +calls=33010 0 +0 118360 +0 6448 +cfn=(4332) +calls=649 0 +0 2015 +0 24075 + +fn=(4952) +0 2415742 + +fn=(4228) malloc +0 796400 +cfn=(4234) +calls=73729 0 +0 12754463 +0 3606950 + +fn=(4462) 0x00000000000b4180 +0 1109825 +cfn=(4234) +calls=63 0 +0 12117 +0 325500 +cfn=(4504) 0x00000000000b2300 +calls=37042 0 +0 3504972 +0 25225 +cob=(3) +cfi=(3) +cfn=(4488) +calls=62 0 +0 325 +0 150 +cfn=(4504) +calls=62 0 +0 2925 +0 4550 + +fn=(4878) free +0 597300 +cfn=(4510) +calls=73671 0 +0 6356086 +0 4530650 + +fn=(4164) +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4178) main +calls=1 0 +0 283054621 + +fn=(4460) realloc +0 1670225 +cfn=(4462) +calls=38415 0 +0 4985589 +0 278025 + +fn=(5714) 0x00000000001972a0 +0 3800475 + +fn=(4504) +0 300600 +cfn=(4510) +calls=37104 0 +0 3082047 +0 125250 + +ob=(6) +fl=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +fn=(5772) >::push_mut +1027 125000 ++2 25000 ++3 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +-62 50000 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +1963 75000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 0 +* 2225000 +fe=(33) +1038 50000 ++4 100000 + +fn=(5888) >>::into_boxed_slice +1723 100100 +fi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +616 25025 +fe=(33) +1598 75075 +fi=(32) +832 25025 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +1401 25025 +fi=(32) +839 50050 +fi=(10) +1401 25025 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +228 75075 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/src/main.rs +cfn=(5522) __rustc::__rust_realloc +calls=37037 41 +* 7258722 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +965 50050 +fe=(33) +1731 125125 + +fl=(55) /rust/deps/hashbrown-0.17.1/src/raw.rs +fn=(6070) as core::ops::drop::Drop>::drop +3486 175 +2656 50 +2271 25 +3498 200 + +fl=(94) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs +fn=(5572) > as core::iter::traits::iterator::Iterator>::next +854 1750350 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +-89 500100 +0 1000200 +fi=(95) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +602 1250250 +cfn=(5576) ::next +calls=370074 1123 +* 28202100 +* 1250250 +fe=(94) +860 175050 ++1 175050 +fi=(95) +604 450000 +fi=(91) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs +129 525000 +fi=(95) +777 225000 +fi=(91) +129 150000 ++4 150000 ++12 150000 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs +1229 75000 +fi=(91) +145 75000 ++1 150000 +fi=(44) +1229 75000 +fi=(91) +262 75000 +129 375000 ++4 150000 ++12 150000 +fi=(44) +1229 75000 +fi=(91) +145 75000 ++1 150000 +fi=(44) +1229 75000 +fi=(91) +262 75000 +fi=(54) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs +871 225000 +fe=(94) +-15 375000 ++5 1750350 + +fl=(53) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs +fn=(5288) as core::hash::Hasher>::write +256 250000 ++2 250000 ++4 750000 +0 500000 +278 250000 ++1 750000 ++3 500000 +0 625000 +fi=(18) +573 125000 +fe=(53) +288 125000 +fi=(10) +2652 125000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +2215 125000 +fi=(10) +2652 125000 +fe=(53) +78 125000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 250000 +fe=(53) +78 125000 +290 125000 ++2 125000 +-10 250000 +0 500000 +126 500000 +fi=(18) +573 200000 +fe=(53) +132 400000 +0 300000 +132 450000 +fi=(54) +871 25000 +fi=(18) +573 25000 +fe=(53) +134 75000 ++1 25000 ++2 500000 ++2 150000 +298 25000 +0 25000 +300 50000 +-2 225000 +0 225000 +300 450000 + +fl=(52) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs +fn=(5702) ::hash_one::<&[u8]> +694 750000 ++5 125000 +fi=(53) +203 250000 +fi=(48) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs +84 125000 +fi=(53) +204 250000 +fi=(48) +84 625000 +fi=(10) +4058 375000 +fi=(53) +233 375000 +cfn=(5288) +calls=185000 +23 +* 6875000 +* 500000 +cfn=(5288) +calls=185000 +23 +* 3650000 ++81 375000 +-2 250000 ++4 250000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 250000 +fi=(53) +78 125000 +318 125000 ++2 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 500000 +fi=(53) +323 375000 +fe=(52) +702 625000 + +fl=(105) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(5744) quick_xml::escape::unescape +236 250000 ++52 25000 +fi=(54) +473 75000 +0 25000 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 50000 +fi=(78) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs +153 125000 +cfi=(84) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs +cfn=(5474) memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 +calls=37000 659 +* 1053000 +fi=(40) +2869 50000 +fe=(105) +321 50000 +fi=(91) +0 25000 +fe=(105) +327 100000 +0 25000 +238 225000 + +fl=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +fn=(4180) std::rt::lang_start_internal +fi=(141) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5136) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 283054621 +fe=(8) + +fn=(5136) +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5138) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 283054621 + +fl=(85) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs +fn=(5486) <&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: +211 1800600 +fi=(33) +3101 150050 +1032 300100 ++1 100 +cfi=(32) +cfn=(5490) >::grow_one +calls=74 186 +* 4800 +fi=(32) +611 150050 +fi=(18) +1963 150050 +fi=(33) +1038 450150 +fi=(76) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs +137 150050 +fe=(85) ++86 150050 +0 450150 +232 450150 +cfi=(87) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs +cfn=(5498) ::feed +calls=222074 57 +* 14181000 +* 300100 +0 150050 +233 450150 +fi=(10) +1092 150050 +fi=(32) +616 150050 +fi=(33) +1461 150050 +fi=(10) +2689 150050 +fi=(32) +764 150050 +-94 150050 +fi=(33) +2981 300000 +0 150050 +fi=(20) +970 150050 +fi=(18) +573 750250 +cob=(2) +cfi=(2) +cfn=(4490) +calls=222074 0 +* 2200650 +* 300100 +fi=(33) +2986 450150 +fi=(43) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +90 150050 +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs +389 450150 +fe=(85) +239 600200 +fi=(43) +544 450150 +90 300100 +fe=(85) +240 300100 +cfi=(37) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +cfn=(5186) core::str::converts::from_utf8 +calls=222074 89 +* 12090575 +fi=(27) +0 300100 +2177 300100 +fe=(85) +253 1200400 +0 150050 +240 600200 +fi=(33) +0 50 +fi=(32) +672 300 +cfn=(5514) >::reserve::do_reserve_and_handle:: +calls=74 -14 +* 6600 +* 100 +fi=(33) +3101 50 +2981 50 +fe=(85) + +fl=(18) +fn=(5586) core::ptr::drop_glue::> +847 700200 +fi=(32) +425 350100 +631 175050 +425 75000 +fi=(10) +1401 75000 +fi=(23) +175 150000 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5662) __rustc::__rust_dealloc +calls=111000 65 +* 2550000 +fe=(18) +847 1925550 + +fn=(6326) core::ptr::drop_glue:: +847 275 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +454 25 +fi=(13) +4049 25 +fi=(73) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2868 25 +fe=(18) +847 450 +cfn=(6327) core::ptr::drop_glue::'2 +calls=37 * +* 12021911 +* 200 +cob=(2) +cfi=(2) +cfn=(4878) +calls=37 0 +* 825 + +fn=(6327) +847 1400275 +fi=(32) +631 50000 +fe=(18) +847 25000 +fi=(26) +65 25000 +fi=(14) +454 25000 +fi=(13) +4049 25000 +fi=(73) +2868 25000 +fe=(18) +847 900000 +cfn=(6327) +calls=111000 * +* 5850511 +* 75000 +fi=(32) +611 25 +fi=(33) +4358 25 +fe=(18) +847 125 +0 25 +847 50 +cfn=(6327) +calls=37 * +* 7861 +* 49950 +cfn=(6327) +calls=36963 * +* 11858982 +* 100000 +fi=(32) +631 50 +fe=(18) +847 175175 +cob=(2) +cfi=(2) +cfn=(4878) +calls=37037 0 +* 4520700 +* 150000 +cob=(2) +cfi=(2) +cfn=(4878) +calls=37000 0 +* 4475511 + +fn=(5778) core::ptr::drop_glue::> +847 1800450 +0 200050 +847 2000500 + +fl=(30) +fn=(5138) +fi=(141) +cfi=(24) +cfn=(5140) xml_diagnostics::main +calls=1 43 +250 283054621 +fe=(30) + +fl=(74) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/parser.rs +fn=(5592) polyxml::parser::resolve_record_schema +155 200200 +fi=(14) +454 25025 +fe=(74) +160 50050 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(96) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(96) +97 25025 +fi=(13) +3994 25025 +fi=(33) +3101 50050 +fi=(13) +4049 25025 +fi=(96) +111 25025 ++7 100100 +fi=(33) +3126 25025 +fe=(74) +160 25025 +fi=(13) +4029 25025 +fi=(73) +2434 25025 +fe=(74) +161 25025 +0 25025 +209 225225 + +fn=(5682) polyxml::parser::is_nil_element +91 525000 +fi=(98) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs +-91 75000 +fi=(99) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +272 75000 +fe=(74) +92 1125000 +-92 75000 +fi=(94) +227 225000 +cfn=(5572) +calls=111000 854 +* 12758500 +* 75000 +cfn=(5572) +calls=37000 854 +* 1600000 +fe=(74) +92 450000 +fi=(101) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +222 25000 +fi=(77) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs +21 50000 +fi=(76) +2635 25000 +fe=(74) +97 50000 +cfi=(101) +cfn=(5686) ::local_name +calls=37000 +44 +* 950000 +fi=(77) +-76 100000 +fi=(18) +847 75000 +fe=(74) +92 225000 ++11 75000 +cfi=(18) +cfn=(5586) +calls=111000 847 +* 2300000 ++2 675000 + +fn=(5866) ::finish +52 225225 +fi=(97) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs +1082 75075 +-30 25025 +-15 25025 +fe=(74) +53 25025 +-53 50 +fi=(97) +1082 25 +fe=(74) +54 300 +fi=(97) +996 50 ++56 25 +-56 25 +fe=(74) +54 25 +fi=(116) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +-30 125 +fe=(74) ++30 25 +fi=(97) +2493 50 +0 125 +fe=(74) +56 200 +fi=(97) +2493 50 +0 25 +2493 50 ++5 50 +1082 50 +-30 25 +fi=(54) +871 25 +fi=(18) +1755 25 +fi=(40) +2869 50 +fi=(116) +80 25 +fi=(40) +2870 50 +fi=(116) +81 25 ++1 50 +fe=(74) +-27 100 ++1 50 +fi=(97) +1082 75 +-17 25 +fi=(43) +245 50 +0 25 +fi=(97) +1082 25 +-17 25 +fi=(43) +245 50 +fi=(18) +847 50 +0 25 +847 25 +cfi=(97) +cfn=(6064) >; 4]> as core::ops::drop::Drop>::drop +calls=37 2483 +* 500 +0 50 +847 25 +cfi=(97) +cfn=(5910) >; 4]> as core::ops::drop::Drop>::drop +calls=37 2373 +* 550 +0 25 +fi=(14) +454 25 +fe=(74) +61 75 +-61 25000 +fi=(14) +454 25000 +fe=(74) +61 50000 ++22 50050 ++1 75075 +fi=(97) +1082 25025 +1607 25025 +fe=(74) +84 25025 +fi=(97) +1615 100100 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37037 0 +* 1926925 +2552 50050 +-1 125125 +fi=(33) +3996 25025 +cfi=(115) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs +cfn=(5870) > as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter +calls=37037 32 +* 11513714 +0 25025 +fe=(74) +84 25025 +cfi=(33) +cfn=(5888) +calls=37037 1723 +* 7834297 +-2 125125 ++4 50050 +fi=(18) +847 50000 +cfi=(97) +cfn=(5910) +calls=37000 2373 +* 550000 +* 75075 +fe=(74) +86 225225 + +fn=(5450) ::deserialize_with_limit +245 275 +fi=(75) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs +810 300 +fi=(33) +462 125 +0 50 +fi=(85) +412 100 +cfi=(75) +cfn=(5452) >::read_event_impl::<&mut alloc::vec::Vec> +calls=37 1006 +* 24725 +fe=(74) +254 225 +fi=(23) +0 25 +fe=(74) +258 25 +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/mod.rs +105 75 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/lazy.rs +-46 50 +fi=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cell.rs +558 50 +fi=(10) +2652 25 +fi=(11) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs +976 25 +fi=(73) +440 200 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) __rustc::__rust_no_alloc_shim_is_unstable_v2 +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) __rustc::__rust_alloc +calls=37 -89 +* 1050 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +251 50 +0 25 +293 200 +fi=(73) ++27 75 +fi=(32) +0 25 +cfi=(6) +cfn=(5100) +calls=37 0 +0 25 +fi=(23) +130 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 3725 +fi=(32) +470 50 +fi=(33) +969 75 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 950 +fi=(28) +251 50 +fe=(74) +0 75 +296 50 +cfn=(5570) polyxml::parser::namespace_scope +calls=37 109 +* 3175 +* 25 +fi=(33) +1196 125 +fe=(74) +298 75 +cfn=(5592) +calls=37 155 +* 1050 +fi=(27) +2177 25 +0 25 +2177 50 +fi=(40) +634 25 +fi=(33) +3101 25 +fe=(74) +31 25 ++1 100 +cfi=(97) +cfn=(5606) ; 8]>>::from_elem +calls=37 2052 +* 3300 +-7 25 ++9 75 +-4 150 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37 -30 +* 1925 +* 75 +300 75 +cfn=(5626) ::parse_attributes +calls=37 566 +* 3075 +fi=(27) +2177 50 +fe=(74) +0 50 +301 50 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37 0 +* 2225 +fi=(33) +1029 25 ++3 50 +fi=(20) +-62 75 +fi=(18) +1963 50 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37 0 +* 2225 +fi=(33) +1038 50 +462 425 +fi=(85) +-50 800100 +cfi=(75) +cfn=(5452) +calls=296037 1006 +* 84615000 +fe=(74) +309 1000125 +0 200025 +309 600075 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fi=(32) +611 75000 +fi=(76) +282 150000 +fe=(74) ++29 150000 +cfn=(5570) +calls=111000 109 +* 20433500 +0 150000 +fi=(33) +1029 75000 ++3 150000 ++1 50 +cfi=(32) +cfn=(5664) >::grow_one +calls=37 186 +* 20817 +fi=(32) +611 75000 +fi=(18) +1963 75000 +fi=(33) +1038 150000 +fe=(74) +312 225000 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fi=(33) +0 75025 +fi=(13) +4049 75025 +fi=(73) +2868 75025 +fe=(74) +511 150050 +-45 100000 +fi=(98) +350 100000 +fi=(54) +871 50000 +fi=(13) +3994 100000 +fi=(78) +153 150000 +cfn=(5796) memchr::arch::x86_64::memchr::memchr_raw::find_avx2 +calls=73999 -75 +* 3000300 +fi=(40) +2869 100000 +fi=(33) +0 225000 +fe=(74) +316 75000 +fi=(33) +3101 75000 +fe=(74) +320 150000 +fi=(98) +0 75000 +fi=(99) +202 75000 +fi=(92) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs +380 150000 +fi=(99) +202 75000 +fi=(92) +384 150000 +fi=(44) +1229 25000 +fi=(91) +424 75000 +0 150000 +fi=(10) +1096 150000 +fi=(43) +90 75000 +fi=(100) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs +-62 150000 ++13 150000 +-41 150000 +42 650000 ++4 325000 +-5 725000 +fi=(54) +-41 75000 +fe=(74) +327 150000 +cfn=(5682) +calls=111000 91 +* 21533500 +* 75000 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fe=(74) +0 75000 +fi=(32) +611 75000 +fi=(76) +282 75000 +fi=(14) +454 75000 +fi=(13) +4029 75000 +fi=(73) +2434 75000 +fe=(74) +329 75000 +fi=(73) +2438 75000 +320 300000 +fi=(55) +1337 75000 +fi=(51) /rust/deps/hashbrown-0.17.1/src/map.rs +-53 75000 +0 75000 +1287 225000 +241 150000 +cfi=(52) +cfn=(5702) +calls=111000 694 +* 13650000 +fi=(102) /rust/deps/hashbrown-0.17.1/src/control/tag.rs +47 225000 +fi=(55) +2452 450000 +0 75000 +fi=(18) +573 75000 +fi=(57) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs +1569 225000 +fi=(103) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs +40 150000 +-40 375000 +fi=(58) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/nonzero.rs +628 75000 +fi=(55) +2032 150000 +fi=(20) +1054 225000 +fi=(77) +21 150000 +-21 75000 +fi=(104) /rust/deps/hashbrown-0.17.1/src/lib.rs +157 225000 +cob=(2) +cfi=(2) +cfn=(5714) +calls=111000 0 +* 1425000 +* 75000 +fi=(47) +455 75000 +fe=(74) +330 150000 +fi=(33) +1865 75000 +fi=(43) +238 150000 +fi=(32) +611 75000 +fi=(43) +238 225000 +fe=(74) ++97 625000 +fi=(28) +2415 25000 +fe=(74) +345 75000 ++13 50000 +fi=(40) +0 75025 +fi=(11) +975 525175 +fe=(74) +515 75025 +fi=(33) +3101 25025 +fe=(74) +526 50050 +fi=(33) +2877 50000 +fi=(54) +871 50000 +fi=(18) +1755 75000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 0 +* 2225000 +fi=(98) +350 100000 +fi=(33) +1865 50000 +fi=(76) +282 100000 +fi=(32) +611 50000 +fi=(76) +282 50000 +fi=(14) +454 50000 +fi=(33) +1865 100000 +fi=(43) +238 100000 +fi=(32) +611 50000 +fi=(43) +238 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +519 150000 +cfi=(106) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/converters.rs +cfn=(5756) ::parse_scalar +calls=74000 28 +* 19637399 +fi=(27) +2177 100000 +0 400000 +2177 100000 +fe=(74) +519 400000 +fi=(33) +1904 50000 +fi=(76) +305 300000 +fe=(74) +521 100000 +0 50000 +472 50000 +fi=(10) +1096 50000 +fi=(43) +90 25000 +fi=(100) +-62 50000 ++13 50000 +-41 25000 +42 200000 ++4 100000 +-5 225000 +fe=(74) +544 50 +fi=(32) ++72 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99950 +0 50000 +fi=(20) +970 50000 +fi=(18) +573 150000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=74000 0 +* 705000 +fi=(33) +2986 100000 +0 100000 +fi=(97) +1082 100000 +-17 50000 +0 25000 +fe=(74) +529 125000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 0 +* 2225000 +* 75000 +cfn=(5866) +calls=37000 52 +* 23353170 +fi=(27) +2177 50000 +0 200000 +2177 50000 +fe=(74) +529 200000 +fi=(33) +1904 25000 +fi=(76) +305 50000 +fi=(32) +611 25000 +fi=(76) +305 25000 +fi=(14) +454 25000 +fi=(55) +1337 25000 +fi=(51) +-53 25000 +fe=(74) +0 100000 +fi=(51) +1287 25000 +241 75000 +cfi=(52) +cfn=(5702) +calls=37000 694 +* 4500000 +* 25000 +fi=(102) +47 50000 +fi=(55) +2452 150000 +0 25000 +fi=(18) +573 25000 +fi=(57) +1569 75000 +fi=(103) +40 50000 +-40 150000 +fi=(58) +628 25000 +fi=(55) +2032 50000 +fi=(20) +1054 100000 +fi=(77) +21 50000 +fi=(104) +157 75000 +cob=(2) +cfi=(2) +cfn=(5714) +calls=37000 0 +* 475000 +* 25000 +fi=(47) +455 25000 +fi=(97) +0 100000 +fi=(43) +245 200000 +fi=(18) +847 100000 +fe=(74) +524 400000 +-3 50000 ++11 25000 +fi=(33) +1865 25000 +fi=(43) +238 75000 +fi=(32) +611 25000 +fi=(43) +238 50000 +fe=(74) +538 100000 +0 25000 +539 50000 +cfn=(5914) ::push_list_item +calls=37000 39 +* 1224450 +* 25000 +fi=(73) +0 200000 +fe=(74) +557 100000 +fi=(73) +0 150000 +fe=(74) +557 550000 +cfi=(18) +cfn=(5778) +calls=296000 847 +* 4000000 +fi=(33) +3082 600000 +fe=(74) +308 200000 ++29 100000 +fi=(33) +1865 25000 +fi=(76) +282 50000 +0 25000 +fi=(32) +611 25000 +fi=(76) +282 50000 +fe=(74) ++84 100000 +cfn=(5592) +calls=37000 155 +* 1050000 +fi=(27) +2177 25000 +0 25000 +2177 50000 +fe=(74) +371 50000 +cfn=(5728) ::new +calls=37000 23 +* 6925000 ++1 100000 +cfn=(5626) +calls=37000 566 +* 27406250 +fi=(27) +2177 50000 +fe=(74) +373 125000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 0 +* 2225000 +fi=(33) +996 75000 +cfn=(5772) +calls=37000 +31 +* 2700000 +* 25000 +fi=(45) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/schema.rs +11 100000 +fi=(33) +3082 150000 +fe=(74) +0 100000 +557 50000 +0 150000 +557 175000 +fi=(33) +0 100000 +fi=(13) +4049 50000 +fi=(73) +2868 50000 +fi=(33) +0 25000 +fi=(13) +4049 25000 +fi=(73) +2868 25000 +fi=(32) +672 150 +cfn=(5514) +calls=37 -14 +* 2875 +fi=(33) +3101 25 +2981 25 +fe=(74) +557 50 +0 25 +557 25 +cfi=(18) +cfn=(5778) +calls=37 847 +* 500 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 3250 +0 25 +fi=(13) +4049 25 +fi=(73) +2868 25 +fi=(13) +4049 25 +fi=(73) +2868 25 +0 50 +2911 25 +cfn=(6068) >>::drop_slow +calls=37 2138 +* 1725 +0 25 +fe=(74) +279 50 +0 25 +279 25 +cfi=(18) +cfn=(5778) +calls=37 847 +* 500 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5662) +calls=37 65 +* 3850 +fe=(74) +286 275 +fi=(33) +2877 25 +fi=(32) +611 50 +fi=(18) +1755 75 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37 0 +* 2225 +fe=(74) +546 75 +cfn=(5866) +calls=37 52 +* 26466 +* 25 + +fn=(5570) +109 525175 ++1 75025 +fi=(98) +0 75025 +fi=(99) +272 75025 +fe=(74) +111 900300 +0 75025 +fi=(94) +227 225075 +cfn=(5572) +calls=111037 854 +* 12760100 +* 75000 +cfn=(5572) +calls=37000 854 +* 1600000 +fe=(74) +111 425075 +fi=(77) +-90 50000 +fi=(76) +2635 25000 +fi=(18) +847 50000 +fi=(32) +0 75025 +fe=(74) +122 75025 +cfi=(18) +cfn=(5586) +calls=111037 847 +* 2300450 ++1 75025 +fi=(40) +1162 150050 +fi=(13) +4029 75025 +fi=(73) +2434 75025 +fe=(74) +124 675225 + +fn=(5914) +39 150000 +fi=(97) +1082 75000 +-30 25000 +-15 25000 +fe=(74) +40 25000 +-40 24975 +fi=(97) +1082 24975 +-17 24975 +fi=(43) +195 50000 +fi=(97) +1082 25000 +-17 25000 +fe=(74) +0 25 +40 50 +fi=(14) +454 25 +fi=(33) +3101 25 +fe=(74) +42 50 +cfi=(97) +cfn=(5918) >; 4]>>::resize_with::<::push_list_item::{closure#0}> +calls=37 1841 +* 1200 +-42 25 +fi=(97) +1082 100 +-17 50 +fe=(74) +44 25000 +fi=(43) +197 50000 +fe=(74) +45 75000 +fi=(33) +1029 24975 ++3 49950 ++1 450 +cfi=(32) +cfn=(5934) >::grow_one +calls=333 186 +* 46350 +fi=(32) +611 24975 +fi=(20) +970 24975 +fi=(18) +1963 199800 +fi=(33) +1038 74925 +fi=(23) +128 25 +cfi=(6) +cfn=(5100) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5102) +calls=37 -89 +* 1050 +fi=(28) +251 50 +fe=(74) +47 225 +fi=(18) +847 50 +fe=(74) +47 75 ++3 150000 + +fn=(5728) +23 150000 +fi=(40) +634 25000 +fi=(33) +3101 25000 +fe=(74) +31 25000 ++1 100000 +cfi=(97) +cfn=(5606) +calls=37000 2052 +* 4250000 +-7 25000 ++9 75000 +-4 125000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 -30 +* 1925000 +* 50000 ++6 150000 + +fn=(5448) polyxml::deserialize +242 50 +cfn=(5450) +calls=37 +3 +* 271030152 + +fn=(5626) +566 200200 +fi=(98) +0 25025 +fi=(99) +272 25025 +fe=(74) +567 325325 +0 25025 +fi=(94) +227 75075 +cfn=(5572) +calls=37037 854 +* 9560100 +* 75000 +cfn=(5572) +calls=37000 854 +* 1600000 +fe=(74) +567 250050 +fi=(101) +222 25000 +fi=(77) +21 50000 +fi=(76) +2635 25000 +fe=(74) +572 50000 +cfi=(101) +cfn=(5686) +calls=37000 141 +* 950000 +0 50000 +fi=(14) +454 25000 +fi=(55) +1337 25000 +fi=(51) +-53 25000 +0 25000 +1287 25000 +241 50000 +cfi=(52) +cfn=(5702) +calls=37000 694 +* 4625000 +fi=(102) +47 75000 +fi=(55) +2452 150000 +0 25000 +fi=(18) +573 25000 +fi=(57) +1569 75000 +fi=(103) +40 50000 +-40 125000 +fi=(58) +628 25000 +fi=(55) +2032 50000 +fi=(20) +1054 75000 +fi=(77) +21 50000 +fi=(104) +157 100000 +cob=(2) +cfi=(2) +cfn=(5714) +calls=37000 0 +* 475000 +* 25000 +fi=(47) +455 25000 +fe=(74) +573 25000 +fi=(33) +1865 25000 +fi=(43) +238 50000 +fi=(32) +611 25000 +fi=(43) +238 50000 +fe=(74) +575 50000 +fi=(98) +350 50000 +fe=(74) +576 50000 +cfi=(105) +cfn=(5744) +calls=37000 236 +* 2078000 +fi=(27) +2177 25000 +0 75000 +2177 50000 +fe=(74) +0 50000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(74) +577 75000 +cfi=(106) +cfn=(5756) +calls=37000 28 +* 2319750 +fi=(27) +2177 50000 +0 200000 +2177 50000 +fe=(74) +577 225000 +fi=(97) +1082 75000 +-17 25000 +fi=(43) +245 50000 +0 25000 +fi=(97) +1082 25000 +-17 25000 +fi=(43) +245 50000 +fi=(18) +847 50000 +fe=(74) +582 200000 +fi=(18) +847 150000 +fi=(23) +0 25025 +fe=(74) +585 25025 +cfi=(18) +cfn=(5586) +calls=37037 847 +* 1400450 +* 25025 ++1 25025 ++1 200200 + +fl=(87) +fn=(5498) +57 1500500 +fi=(54) +473 450150 +fi=(13) +3994 300100 +fi=(78) +153 900300 +cfi=(84) +cfn=(5504) memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 +calls=222073 1042 +* 4203450 +fi=(40) +2869 300100 +fi=(88) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs +0 150050 +fi=(54) +623 300100 +fe=(87) +59 300100 +fi=(54) +871 150050 +fe=(87) +59 625200 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5504) +calls=37000 1042 +* 700000 +fi=(40) +2869 50000 +fi=(88) +0 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 375100 +-59 150050 +59 600200 +-59 150050 +59 200050 ++14 1350450 +fi=(88) +-73 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 75000 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5504) +calls=37000 1042 +* 700000 +fi=(40) +2869 50000 +fe=(87) + +fl=(106) +fn=(5756) +28 600000 ++5 825000 +-33 25000 +cfi=(37) +cfn=(5186) +calls=37000 89 +0 1961250 +0 50000 +fi=(27) +2177 50000 +fi=(109) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/lib.rs +0 25000 +fi=(47) +478 25000 +fi=(32) +-17 25000 +0 25000 +cfi=(6) +cfn=(5100) +calls=37000 0 +0 25000 +0 25000 +fi=(23) +130 75000 +cfi=(24) +cfn=(5102) +calls=37000 -89 +* 10665349 +fi=(32) +470 50000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +0 25000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37000 0 +* 330000 +* 25000 +0 25000 +fi=(76) +199 50000 +fi=(56) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs +434 75000 +0 25000 +434 75000 +fi=(47) +0 25000 +fe=(106) +35 75000 +-35 25000 +fi=(76) +199 50000 +0 75000 +fi=(56) +434 75000 +fi=(76) +0 250000 +fi=(56) +434 75000 +0 25000 +434 175000 +0 25000 +434 75000 +fi=(110) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs +175 100000 +fi=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs ++24 175000 +fi=(43) +0 50000 +fi=(111) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs +252 150000 +0 25000 +fi=(43) +184 50000 +fi=(110) +872 205600 +fi=(10) +2689 102800 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +39 205600 +fi=(10) +2728 77800 +fi=(110) +566 77800 +fi=(10) +2652 77800 +fi=(108) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs +144 77800 +fi=(43) ++40 155600 +fi=(107) +677 25000 ++10 25000 +0 50000 +411 50000 +fi=(10) +2689 25000 +fi=(124) +39 50000 +fi=(107) +411 94500 +fi=(10) +2689 47250 +fi=(124) +39 94500 +fi=(108) +270 72250 +fi=(145) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 72250 +fi=(113) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +132 72250 +fi=(145) +2189 72250 +fi=(43) +184 144500 +fe=(106) +46 75000 ++45 675000 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2105 25000 +fi=(110) +616 25000 +0 50000 +fi=(43) +380 25000 +fi=(111) +252 100000 +fi=(43) +-68 50000 +fi=(110) +872 100000 +fi=(10) +2689 50000 +fi=(124) +39 100000 +fi=(10) +2728 50000 +fi=(110) +623 50000 +fi=(10) +2652 50000 +fi=(108) +144 50000 +fi=(43) ++40 100000 +0 50000 +90 25000 +fi=(110) +616 225000 +0 25000 +568 100000 +fi=(43) +184 50000 +fi=(110) +666 50000 +0 25000 +747 50000 +0 25000 +747 25000 +855 50000 +216 300000 ++51 25000 +cfi=(112) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs +cfn=(5860) ::try_fast_path:: +calls=37000 45 +* 675000 +* 50000 +fe=(106) +56 75000 + +fl=(90) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs +fn=(5536) ::emit_start +314 750250 +fi=(92) ++70 150050 +fi=(44) +1229 75025 +fi=(91) +493 75025 +0 75025 +221 150050 +fi=(76) +2736 150050 +fi=(77) +157 75025 +fi=(76) +2738 75025 +0 75025 +2738 75025 +fe=(90) +345 150050 +fi=(10) +1092 75025 +fi=(92) +380 150050 ++4 150050 +fi=(44) +1229 75025 +fi=(91) +424 75025 +0 225075 +fi=(93) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs +331 325175 +-4 650350 ++1 700350 +-13 350175 +0 50000 +fi=(33) +3101 25000 +1029 25000 ++3 50000 +fi=(32) +611 75025 +fi=(18) +1963 75025 +fi=(33) +1038 150050 +fi=(92) +380 150050 ++4 150050 +fi=(44) +1229 25000 +fi=(91) +424 25000 +fi=(33) +1033 100 +cfi=(32) +cfn=(5552) >::grow_one +calls=37 186 +* 2675 +* 75 +0 50025 +3101 50025 +1029 50025 ++3 100075 +fi=(91) +424 50025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +0 75025 +fi=(20) +970 75025 +fi=(18) +573 300100 +cob=(2) +cfi=(2) +cfn=(4490) +calls=111037 0 +* 1125375 +* 75025 +fi=(33) +2986 225075 +fe=(90) +0 450150 +356 675225 +fi=(32) +672 250 +cfn=(5514) +calls=74 -14 +* 5825 +* 50 +fi=(33) +3101 100 +fe=(90) + +fn=(5788) ::emit_text +63 50000 ++1 100000 ++11 200000 ++1 150000 + +fn=(5818) ::emit_end +197 525175 +fi=(91) +-68 150050 +fi=(44) +1229 75025 +fi=(91) +145 75025 +fi=(44) +1229 75025 +fi=(91) +262 75025 +0 300100 +fe=(90) +214 225075 +fi=(93) +315 300100 +0 75025 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +402 150050 +fi=(93) +-87 75025 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fe=(90) +228 150050 +fi=(32) +611 75025 +fi=(33) +1865 75025 +fi=(92) +380 150050 ++4 150000 +fi=(44) +1229 75000 +fi=(91) +493 75000 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1490 150050 +fi=(92) +380 450150 +fi=(32) +611 75000 +fi=(44) +1229 75000 +fi=(39) +1491 75000 +fi=(33) +1828 75025 +fe=(90) +257 375125 ++1 675225 +fi=(92) +384 225075 +fi=(91) +221 150050 +fi=(54) +871 75025 +fi=(77) +21 150050 +-21 75025 +157 600200 +cob=(2) +cfi=(2) +cfn=(5714) +calls=111037 0 +* 1425475 +* 450150 +fe=(90) ++73 75025 +fi=(92) +394 75025 +fi=(91) ++30 75025 +fe=(90) + +fl=(6) +fn=(4128) (below main) +cob=(2) +cfi=(2) +cfn=(4130) +calls=1 0 +0 283054621 + +fn=(5100) +0 125250 + +fn=(4178) +cfi=(8) +cfn=(4180) +calls=1 152 +0 283054621 + +fl=(112) +fn=(5860) +45 75000 +-45 25000 +46 50000 +-46 50000 +46 100000 ++36 50000 +fi=(113) ++70 50000 +fe=(112) +-67 50000 ++22 25000 +fi=(114) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/table_decimal.rs +-30 75000 +fi=(146) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/arith.rs +515 50000 +fe=(112) +100 75000 + +fl=(84) +fn=(5474) +659 350100 +fi=(78) +0 700200 +fi=(54) +623 350100 +fe=(84) ++40 350100 ++1 50100 +fi=(88) +1161 50050 +0 25025 +1162 25025 +fe=(84) +668 50050 +fi=(88) +1162 47250 +fe=(84) +668 239000 +fi=(54) +389 72250 +fi=(88) +1161 144500 +0 25000 +fi=(78) +86 75000 +fi=(18) +573 150000 +fi=(147) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs +699 300000 +2315 150000 +2163 150000 +fi=(148) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/vector.rs +147 150000 +fi=(88) +679 150000 +fi=(18) +573 25 +fi=(57) +920 50 +-25 25 +1569 25 +fi=(148) +147 25 +fi=(88) +679 25 +fe=(84) +0 450075 +fi=(78) +86 300100 +fe=(84) + +fn=(5504) +1042 400100 +0 1400350 +fi=(54) +623 400100 +fe=(84) +1046 400100 ++1 150 +fi=(88) +1161 50 +0 25 +1162 50 +fe=(84) +1051 25 +fi=(88) +1162 400 +fe=(84) +1051 1050 +fi=(54) +389 200 +fi=(88) +1161 400 +fi=(18) +573 199975 +fi=(147) +699 399950 +2315 199975 +699 199975 +2315 199975 +2163 199975 +fi=(148) +147 199975 +fi=(88) +972 199975 +fi=(18) +573 50 +fi=(57) +920 100 +-25 50 ++25 50 +-25 50 +1569 50 +fi=(148) +147 50 +fi=(88) +972 50 +fe=(84) +0 800100 +fi=(78) +86 400050 +-86 25 +86 50 +fe=(84) + +fl=(32) +fn=(5642) >>::grow_one +186 300000 +493 75000 ++30 75000 +fi=(19) +1051 225000 +fe=(32) +529 450000 +cfn=(5228) ::finish_grow +calls=111000 +15 +* 6225000 +fi=(27) +2177 150000 ++1 75000 +fe=(32) +773 75000 ++1 75000 +189 300000 + +fn=(5664) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5228) +calls=37 +15 +* 20217 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fn=(5490) +186 300 +493 50 ++30 50 +fi=(19) +1051 150 +fe=(32) +529 200 +cfn=(5228) +calls=74 +15 +* 3550 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +189 250 + +fn=(5228) +544 2600 +fi=(10) +3212 2600 +fi=(47) +478 975 +0 325 +fe=(32) +631 325 +fi=(10) +1401 300 +fi=(23) +228 1500 +cfi=(24) +cfn=(5522) +calls=1451 41 +* 53967 +fi=(27) +965 600 +fi=(23) +298 50 ++4 25 +cfi=(6) +cfn=(5100) +calls=39 0 +* 25 +130 75 +cfi=(24) +cfn=(5102) +calls=39 -89 +* 950 +fi=(27) +965 50 ++1 975 +fe=(32) +0 650 +564 1950 +-20 600600 +fi=(10) +3212 600600 +fi=(47) +478 225225 +fe=(32) +631 150150 +fi=(10) +1401 25 +fi=(23) +228 125 +cfi=(24) +cfn=(5522) +calls=1037 41 +* 1400 +fi=(27) +965 50 +fi=(23) +298 150100 ++4 75050 +cfi=(6) +cfn=(5100) +calls=111074 0 +* 75050 +130 225150 +cfi=(24) +cfn=(5102) +calls=111074 -89 +* 3152000 +fi=(27) +965 150100 ++1 225225 +fe=(32) +0 150150 +564 450450 +-20 400 +fi=(86) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/layout.rs +75 50 ++38 50 +0 50 +fe=(32) +631 100 +fi=(23) +298 100 +128 50 +cfi=(6) +cfn=(5100) +calls=74 0 +* 50 ++2 150 +cfi=(24) +cfn=(5102) +calls=74 -89 +* 1900 +fi=(27) +965 100 ++1 150 +fe=(32) +0 100 +564 300 + +fn=(5514) +658 300 +512 150 +fi=(10) +938 75 +fi=(47) +478 75 +0 75 +fe=(32) +523 150 +fi=(19) +1051 150 +fe=(32) +159 525 +fi=(19) +1051 225 +fe=(32) +529 300 +cfn=(5228) +calls=1118 +15 +* 6775 +fi=(27) +2177 150 ++1 75 +fe=(32) +773 75 ++1 75 +668 300 +-10 150 +fi=(10) +938 50 +fi=(47) +478 50 +0 50 +fe=(32) +523 100 +fi=(19) +1051 250 +fe=(32) +529 350 +cfn=(5228) +calls=1074 +15 +* 4375 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +668 200 + +fn=(5934) +186 900 +493 225 ++30 225 +fi=(19) +1051 675 +fe=(32) +529 1350 +cfn=(5228) +calls=333 +15 +* 40950 +fi=(27) +2177 450 ++1 225 +fe=(32) +773 225 ++1 225 +189 900 + +fn=(5552) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5228) +calls=37 +15 +* 2075 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fl=(26) +fn=(5662) +65 75200 +cob=(2) +cfi=(2) +cfn=(4878) +calls=112323 -65 +* 2487000 + +fl=(115) +fn=(5870) +32 200200 +fi=(97) +2493 100100 +0 25025 +2498 50050 +1082 25025 +-30 25025 +fi=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs +0 25025 +26 225225 +fi=(97) +2506 25025 +fi=(10) +-10 75075 +fi=(19) +1051 75075 +fi=(10) +3212 25025 +fi=(41) +0 25025 +fi=(47) +478 75075 +fi=(97) +1052 25025 +fi=(54) +871 25025 +fi=(18) +1755 25025 +fi=(41) +24 50050 +fe=(115) ++10 200200 +fi=(32) +461 50050 +0 25025 +cfi=(6) +cfn=(5100) +calls=37037 0 +0 25025 +0 25025 +fi=(23) +130 75075 +cfi=(24) +cfn=(5102) +calls=37037 -89 +* 4833839 +fi=(32) +470 50050 +0 50050 +fi=(18) +1963 200200 +fi=(41) +36 100100 ++5 100100 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37037 -41 +* 1926925 +fi=(97) +2493 125125 +0 50 +2493 50 +0 100000 +fi=(33) +4100 225000 +fi=(18) +1963 400000 +fi=(33) +4111 50000 +2224 50000 +fi=(97) +2493 150000 ++5 100000 +fi=(18) +1755 50000 +fi=(33) +4100 550000 ++2 100000 +fi=(97) +0 75000 +2493 50000 +0 25025 +fi=(18) +847 25025 +cfi=(97) +cfn=(5882) ; 8]> as core::ops::drop::Drop>::drop +calls=37037 2373 +* 525525 +fi=(41) +42 150150 +fe=(115) + +fl=(75) +fn=(5452) +1006 3000750 +289 600150 +fi=(76) +2635 50 +fi=(77) +157 125 +fi=(85) +24 25 +fe=(75) +306 25 ++45 300100 +fi=(33) +3101 150050 +fi=(76) +137 300100 +0 300100 +fi=(54) +871 150050 +fi=(13) +3994 300100 +fi=(78) +153 750250 +cfi=(84) +cfn=(5474) +calls=222073 659 +* 3301100 +fi=(40) +2869 300100 +fi=(85) +72 600200 ++7 100000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 100000 +-94 50000 +fi=(20) +970 50000 +fi=(18) +573 200000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=74000 0 +* 705000 +* 100000 +fi=(33) +2986 100000 +fi=(85) +0 50000 +fi=(43) +549 100000 +fi=(142) +389 100000 +fi=(43) +544 50000 +fi=(85) +79 100000 +fi=(43) +544 150000 +90 100000 +fi=(85) +-4 150000 +cfi=(37) +cfn=(5186) +calls=74000 +3 +* 3700250 +* 100000 +-25 100000 +fe=(75) +369 100000 +fi=(85) +75 100050 +fe=(75) +355 100050 +0 400200 +437 100050 +fi=(43) +544 200100 +fe=(75) +437 50000 +fi=(43) +544 100000 +fe=(75) +0 150050 +fi=(43) +90 150050 +fi=(76) ++66 300100 +fi=(142) +389 300100 +fi=(76) +156 150050 +fi=(71) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs +716 450150 +fe=(75) +440 150050 +0 150050 +440 450150 +0 75025 +464 225075 +cfi=(85) +cfn=(5486) +calls=111037 211 +* 19183725 +-1 150050 ++4 375125 +cfi=(90) +cfn=(5818) +calls=111037 197 +* 8702725 +* 75025 +0 75025 +488 225075 +cfi=(85) +cfn=(5486) +calls=111037 211 +* 22204750 +-1 150050 +0 150000 +cfi=(90) +cfn=(5788) +calls=74000 63 +0 500000 +fi=(27) +2177 50000 +0 200000 +2177 100000 +fe=(75) +491 375125 +cfi=(90) +cfn=(5536) +calls=111037 314 +* 9137500 +* 75025 +0 300000 +375 50000 ++25 750250 +1011 1800450 + +fl=(37) +fn=(5186) +89 1125250 +fi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 675150 ++12 450100 +0 1575350 +164 225050 ++1 450100 +fi=(10) +2689 450100 +3875 225050 +fi=(38) +222 225050 ++2 450100 ++17 450100 +0 225050 +241 3590050 ++1 1795025 +-1 3815100 +fe=(37) +94 900200 +-94 225050 +98 900200 + +fl=(24) +fn=(5140) +cfn=(6388) measured_region +calls=1 79 +70 283054621 + +fn=(6388) +79 9 +fi=(19) +2144 1 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 1 +0 10 +fi=(26) +0 5 +fi=(149) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 4 +fi=(13) +4029 1 +fi=(73) +2434 1 +fi=(26) +0 24 +fi=(149) +491 96 +fi=(13) +4029 24 +fi=(73) +2434 24 +fe=(24) +89 125 +cfi=(74) +cfn=(5448) +calls=25 242 +* 271030202 +fi=(27) +1230 50 ++1 200 +fe=(24) +89 50 +cfi=(18) +cfn=(6326) +calls=25 847 +* 12023736 +fi=(19) +2144 25 +fi=(34) +1100 25 +fe=(24) +94 8 + +fn=(5102) +41 125250 +fi=(13) +3994 125250 +762 125250 +fe=(24) +16 125250 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 501000 +fi=(26) +30 250500 ++1 250500 +cob=(2) +cfi=(2) +cfn=(4228) +calls=186395 -31 +* 17157813 +fe=(24) + +fn=(5522) +41 25350 +fi=(13) +3994 25350 +762 25350 +fe=(24) +33 25350 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 126750 +405 50700 +fi=(26) +70 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4460) +calls=37037 -71 +* 6883347 +-1 650 ++1 650 +cob=(2) +cfi=(2) +cfn=(4460) +calls=2488 -71 +* 50492 +fe=(24) + +fl=(78) +fn=(5796) +78 50000 +fi=(84) +184 100000 +0 150000 +fi=(54) +623 100000 +fi=(84) +188 100000 ++1 100000 +fi=(88) +1161 50000 +0 50000 +fi=(84) +193 1050150 +fi=(54) +389 350050 +fi=(88) +1161 700100 +0 100000 +fe=(78) +86 100000 + +fl=(97) +fn=(5606) +2052 250250 ++1 50050 +fi=(32) +0 25025 +fe=(97) +856 25025 +fi=(18) +-9 25025 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fe=(97) +0 25025 +fi=(40) +2274 50050 ++2 25025 +fi=(18) +1963 400400 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fi=(40) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fi=(40) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fe=(97) +2615 50050 +2067 100100 +cob=(2) +cfi=(2) +cfn=(4490) +calls=37037 0 +* 1926925 +fi=(18) +847 25025 +fe=(97) +2069 225225 + +fn=(5882) +2373 200200 +1082 50050 +2375 25025 +fi=(18) +847 50050 +fe=(97) +2382 200200 + +fn=(6064) +2483 250 ++10 50 +-8 200 + +fn=(5910) +2373 200200 +1082 50050 +2375 25025 +fi=(23) +0 25025 +fi=(18) +847 50050 +fe=(97) +2382 200200 + +fn=(5918) +1841 200 +1082 75 +-30 25 +0 25 +1846 75 +1082 50 +-17 25 +0 25 +1358 75 +0 50 +1230 50 +fi=(20) +970 25 +fi=(18) +1963 100 +fe=(97) +1237 25 +fi=(19) +2144 25 +fi=(34) +1100 50 +fi=(74) +42 25 +fe=(97) +1082 50 +1217 25 +1856 200 + +fl=(73) +fn=(6068) +2138 75 ++6 25 +fi=(18) +842 25 ++5 25 +cfi=(55) +cfn=(6070) +calls=37 3486 +* 450 +fi=(117) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/rc.rs +3277 25 +fe=(73) +3392 25 +fi=(13) +4049 25 +fe=(73) +3544 25 +fi=(23) +175 175 +cfi=(26) +cfn=(5662) +calls=37 65 +* 850 +fe=(73) + +fl=(101) +fn=(5686) +141 250000 ++69 250000 +fi=(10) +1096 100000 +fi=(43) +90 50000 +fi=(100) +-62 100000 ++13 100000 +-41 100000 +42 200000 ++4 100000 +-5 250000 +fi=(54) +-41 50000 +fe=(101) +143 350000 + +fl=(95) +fn=(5576) +1123 1750350 ++1 750150 +955 750150 ++2 250050 +1124 250050 +fi=(43) +544 500100 +fi=(14) +1663 500100 +fi=(50) +180 250050 +fe=(95) +1125 75000 +fi=(43) +90 375000 +-90 75000 +fe=(95) +1130 75000 +fi=(14) +627 75000 +fe=(95) +1130 75000 +fi=(93) +315 75000 +fe=(95) +1130 75000 +fi=(14) +627 75000 +fe=(95) +1130 75000 +fi=(93) +315 75000 +0 225000 +fi=(50) +180 75000 +fe=(95) +0 75000 +fi=(50) +180 75000 +fe=(95) +1138 175050 ++1 175050 +0 75000 +fi=(50) +180 75000 +fe=(95) +1143 300000 +fi=(14) +1663 150000 +fi=(50) +180 75000 +fe=(95) +1143 450000 +0 375000 +1188 525000 +0 175050 +1261 2250450 +-73 450000 +cfn=(5638) ::check_for_duplicates +calls=111000 1036 +* 12075000 +* 150000 +fi=(14) +1663 300000 +fi=(50) +180 75000 +0 225000 +fe=(95) +1199 150000 +fi=(93) +315 75000 +0 150000 +fe=(95) +0 225000 +fi=(14) +1663 150000 +fi=(50) +180 300000 +fe=(95) +1243 75000 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs +2490 75000 +fe=(95) +1243 216750 +fi=(150) +2490 216750 +fi=(14) +627 216750 +1663 433500 +fi=(50) +180 216750 +fi=(93) +0 150000 +fe=(95) +1243 75000 +0 150000 +1243 150000 +1113 150000 +0 375000 + +fn=(5638) +1036 525000 ++5 150000 +0 150000 +fi=(33) +3101 75000 +fe=(95) +1042 150000 +0 300000 +fi=(32) +611 150000 +fi=(20) +970 300000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fe=(95) +0 225000 +fi=(33) +1032 150000 ++1 75000 +cfi=(32) +cfn=(5642) +calls=111000 186 +* 8025000 +fi=(32) +611 150000 +0 225000 +fi=(18) +1963 225000 +fi=(33) +1038 225000 +fe=(95) ++16 225000 ++1 600000 + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4128) +calls=1 0 +0 283054621 + +totals: 283054621 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-annotated.txt new file mode 100644 index 0000000..bfc6d7f --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-annotated.txt @@ -0,0 +1,98 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/old/write-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 30027593 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics write 1000 25 instructions (PID 341931, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +80,501,030 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +7,202,000 ( 8.95%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +6,239,250 ( 7.75%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +6,077,100 ( 7.55%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs: as core::io::cursor::WriteThroughCursor>::write_all [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +5,500,000 ( 6.83%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/serializer.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +5,226,325 ( 6.49%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs:>>>::write_event:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +2,962,775 ( 3.68%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,725,825 ( 3.39%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs:>>>::write_event:: +2,500,200 ( 3.11%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +2,426,375 ( 3.01%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs:::format_scalar_to +2,100,350 ( 2.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +2,050,200 ( 2.55%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> +1,950,000 ( 2.42%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/serializer.rs:::format_scalar_to [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +1,575,375 ( 1.96%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>>>::write_event:: +1,328,450 ( 1.65%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs:::format_scalar_to +1,200,400 ( 1.49%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/io/cursor.rs:>>>::write_event:: +1,187,750 ( 1.48%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] +1,175,000 ( 1.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 +1,100,400 ( 1.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:>>>::write_event:: +1,079,375 ( 1.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>::reserve::do_reserve_and_handle:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] +1,062,650 ( 1.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 950,000 ( 1.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 916,750 ( 1.14%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 900,375 ( 1.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::io::cursor::WriteThroughCursor>::write_all + 877,975 ( 1.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 825,925 ( 1.03%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 775,225 ( 0.96%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>>>::write_event:: + 651,125 ( 0.81%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 600,150 ( 0.75%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs:>>>::write_event:: + 575,000 ( 0.71%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 550,250 ( 0.68%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>>::write_event:: + 500,000 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attribute::<(&str, &str)> + 475,825 ( 0.59%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>>::write_event:: + 466,750 ( 0.58%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 451,575 ( 0.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 450,225 ( 0.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 450,150 ( 0.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 450,150 ( 0.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 450,000 ( 0.56%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attribute::<(&str, &str)> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 425,425 ( 0.53%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/schema.rs:::matches_variant [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 425,000 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attr [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 400,000 ( 0.50%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::push_attr + 375,000 ( 0.47%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 351,225 ( 0.44%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs:__rustc::__rust_realloc + 350,000 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attr + 325,025 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:>>>::write_event:: + 325,000 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 314,000 ( 0.39%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 302,200 ( 0.38%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/serializer.rs:::write_model::<&mut core::io::cursor::Cursor>> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 300,000 ( 0.37%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:>::from [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics] + 300,000 ( 0.37%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 275,000 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::format_scalar_to + 250,875 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 250,875 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:>::reserve::do_reserve_and_handle:: + 250,875 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 225,975 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs: as core::io::cursor::WriteThroughCursor>::write_all + 225,225 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:::matches_variant + 225,075 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs: as core::io::cursor::WriteThroughCursor>::write_all + 225,000 ( 0.28%) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/schema.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 225,000 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::push_attr + 225,000 ( 0.28%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 200,700 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_realloc + 200,000 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 200,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attribute::<(&str, &str)> + 199,125 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::format_scalar_to + 175,700 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 175,000 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 150,525 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::reserve::do_reserve_and_handle:: + 150,050 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>>>::write_event:: + 150,000 ( 0.19%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs:::format_scalar_to + 150,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attr + 150,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs:::write_model::<&mut core::io::cursor::Cursor>>'2 + 150,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::push_attr + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-valgrind.txt new file mode 100644 index 0000000..b32187b --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-valgrind.txt @@ -0,0 +1,12 @@ +==341931== Callgrind, a call-graph generating cache profiler +==341931== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==341931== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==341931== Command: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics write 1000 25 instructions +==341931== Parent PID: 341905 +==341931== +==341931== For interactive control, run 'callgrind_control -h'. +==341931== +==341931== Events : Ir +==341931== Collected : 80501030 +==341931== +==341931== I refs: 80,501,030 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000.callgrind new file mode 100644 index 0000000..9e5e99d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/old/write-1000.callgrind @@ -0,0 +1,1891 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 341931 +cmd: benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics write 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 30027593 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 80501030 + + +ob=(3) ??? +fl=(3) ??? +fn=(4488) 0x000000000495a6a0 +0 200 +cob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +cfi=(2) ??? +cfn=(4490) 0x0000000000197a00 +calls=210 0 +0 620650 + +ob=(2) +fl=(2) +fn=(4504) 0x00000000000b2300 +0 2100 +cfn=(4510) 0x00000000000b20e0 +calls=2274 0 +0 19350 +0 875 + +fn=(4130) (below main) +cfn=(4164) 0x000000000002a580 +calls=1 0 +0 80501030 + +fn=(4510) +0 18350 +cfn=(4952) 0x00000000000b0f70 +calls=722 0 +0 3050 +0 1125 + +fn=(4490) +0 7202000 + +fn=(4976) 0x0000000000198400 +0 103400 + +fn=(4234) 0x00000000000b2400 +0 20825 +cfn=(4952) +calls=36 0 +0 775 +0 15325 +cfn=(4952) +calls=749 0 +0 2800 +0 2075 + +fn=(4952) +0 8275 + +fn=(4228) malloc +0 400 +cfn=(4234) +calls=4089 0 +0 10525 +0 650725 + +fn=(4462) 0x00000000000b4180 +0 1182900 +cfn=(4234) +calls=163 0 +0 31275 +0 1675 +cfn=(4504) +calls=2112 0 +0 8425 +0 1050 +cfn=(4952) +calls=109 0 +0 1650 +0 1325 +cob=(3) +cfi=(3) +cfn=(4488) +calls=162 0 +0 620850 +0 600 +cfn=(4504) +calls=162 0 +0 13900 +0 200 + +fn=(4878) free +0 300 +cfn=(4510) +calls=4022 0 +0 3175 +0 825625 + +fn=(4164) +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4178) main +calls=1 0 +0 80501030 + +fn=(4460) realloc +0 2685850 +cfn=(4462) +calls=38275 0 +0 1863850 +0 276925 + +ob=(6) +fl=(109) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/lib.rs +fn=(6078) polyxml::serialize +38 50 +fi=(118) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/serializer.rs +169 125 +cfn=(6080) ::serialize_with_options +calls=36 +3 +* 80496025 +* 25 +fe=(109) +45 75 + +fl=(105) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(6220) quick_xml::escape::_escape::::{closure#0}, &str> +201 500000 ++3 50000 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +1663 50000 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 50000 +0 250000 +180 250000 +0 150000 +fi=(14) +1663 675100 +fi=(50) +385 337550 +fi=(14) +1663 337550 +fi=(50) +180 337550 +379 675100 +fe=(105) +109 337550 +0 712650 +218 250000 ++7 200000 ++2 450000 + +fn=(6196) quick_xml::escape::_escape::::{closure#0}, &str> +201 225000 ++3 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 225000 +fi=(14) +1663 144500 +fi=(50) +385 72250 +fi=(14) +1663 144500 +fi=(50) +379 144500 +fe=(105) +169 72250 +0 144500 +218 75000 ++7 125000 ++2 225000 + +fl=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +fn=(4180) std::rt::lang_start_internal +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfn=(5136) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 80501030 +fe=(8) + +fn=(5136) +cfi=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +cfn=(5138) std::sys::backtrace::__rust_begin_short_backtrace:: +calls=1 162 +206 80501030 + +fl=(122) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/cursor.rs +fn=(6146) as core::io::cursor::WriteThroughCursor>::write_all +315 1800600 +fi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +616 225075 +fe=(122) +199 225075 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +2496 900300 +fe=(122) +136 450150 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +3101 75 +fe=(122) +146 75 +fi=(10) +2689 75 +fi=(32) +764 75 +-94 75 +fi=(33) +3101 225000 +fe=(122) +151 675000 +fi=(32) +672 600 +cfn=(5514) >::reserve::do_reserve_and_handle:: +calls=108 -14 +* 38600 +* 150 +fi=(33) +3101 75 +fe=(122) +151 225 ++54 225075 +fi=(20) +970 225075 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +664 450150 +cob=(2) +cfi=(2) +cfn=(4490) +calls=324108 0 +* 3476175 +fe=(122) +206 450150 +fi=(33) +2224 225075 +fe=(122) +212 225075 +319 2025675 + +fl=(30) +fn=(5138) +fi=(142) +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/old/src/main.rs +cfn=(5140) xml_diagnostics::main +calls=1 43 +250 80501030 +fe=(30) + +fl=(6) +fn=(4128) (below main) +cob=(2) +cfi=(2) +cfn=(4130) +calls=1 0 +0 80501030 + +fn=(5100) __rustc::__rust_no_alloc_shim_is_unstable_v2 +0 25025 + +fn=(4178) +cfi=(8) +cfn=(4180) +calls=1 152 +0 80501030 + +fl=(32) +fn=(5228) ::finish_grow +544 201400 +fi=(10) +3212 201400 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +478 75525 +0 25175 +fe=(32) +631 25175 +fi=(10) +1401 25175 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +228 125875 +cfi=(24) +cfn=(5522) __rustc::__rust_realloc +calls=36276 41 +* 4179250 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +965 50350 ++1 75525 +fe=(32) +0 50350 +564 151050 +-20 200000 +fi=(10) +3212 200000 +fi=(47) +478 75000 +fe=(32) +631 50000 +fi=(10) +1401 25000 +fi=(23) +228 125000 +cfi=(24) +cfn=(5522) +calls=36002 41 +* 1400000 +fi=(27) +965 50000 ++1 75000 +fe=(32) +0 50000 +564 150000 + +fn=(5514) +658 100700 +512 50350 +fi=(10) +938 25175 +fi=(47) +478 25175 +0 25175 +fe=(32) +523 50350 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +1051 50350 +fe=(32) +159 176225 +fi=(19) +1051 75525 +fe=(32) +529 100700 +cfn=(5228) +calls=36258 +15 +* 5186250 +fi=(27) +2177 50350 ++1 25175 +fe=(32) +773 25175 ++1 25175 +668 100700 +-10 75000 +fi=(10) +938 25000 +fi=(47) +478 25000 +0 25000 +fe=(32) +523 50000 +fi=(19) +1051 125000 +fe=(32) +529 175000 +cfn=(5228) +calls=36004 +15 +* 2400000 +fi=(27) +2177 50000 ++1 25000 +fe=(32) +773 25000 ++1 25000 +668 100000 + +fl=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +fn=(5662) __rustc::__rust_dealloc +65 25000 +cob=(2) +cfi=(2) +cfn=(4878) +calls=42043 -65 +* 825000 + +fl=(121) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs +fn=(6138) >>>::write_event:: +262 1600400 +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs +792 600150 +fe=(121) +264 600150 ++1 375125 ++53 75025 +0 75025 +318 75025 +-31 250000 ++26 50000 +fi=(32) +616 50000 +fi=(122) +199 50000 +fi=(10) +2496 200000 +fi=(122) +136 100000 +fi=(33) +3101 75 +fi=(122) +146 75 +fi=(10) +2689 75 +fi=(32) +764 75 +-94 75 +0 50000 +fi=(33) +3101 50000 +fi=(122) +151 150000 +fe=(121) +272 375125 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +765 225075 +fi=(122) +205 50000 +fi=(20) +970 50000 +fi=(18) +664 250000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=72000 0 +* 705300 +fi=(122) +206 100000 +fi=(33) +2224 50000 +fi=(122) +212 100000 +fi=(18) +847 150000 +fi=(23) +0 150000 +fi=(18) +847 50000 +fe=(121) +0 75025 +318 75025 +fi=(32) +616 75025 +fi=(122) +199 75025 +fi=(10) +2496 300100 +fi=(122) +136 150050 +fi=(32) +0 75025 +fi=(33) +3101 75025 +fi=(122) +151 225075 ++54 75025 +fi=(18) +664 75025 +fi=(122) +206 150050 +fi=(33) +2224 75025 +fi=(122) +212 75025 +fi=(119) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/io/cursor.rs +508 300100 +cfi=(122) +cfn=(6146) +calls=108036 315 +* 3891025 +0 75025 +fi=(27) +2177 150050 +fi=(119) +508 300100 +cfi=(122) +cfn=(6146) +calls=108036 315 +* 3976325 +0 75025 +fi=(40) +765 150050 +fi=(18) ++82 300100 +fi=(23) +175 100000 +cfi=(26) +cfn=(5662) +calls=36000 65 +* 850000 +0 75025 +fi=(18) +847 75025 +fi=(40) +-82 400100 +fe=(121) +308 1600400 +fi=(32) +616 75025 +fi=(122) +199 75025 +fi=(10) +2496 300100 +fi=(122) +136 150050 +fi=(33) +3101 25 +fi=(122) +146 25 +fi=(10) +2689 25 +fi=(32) +764 25 +-94 25 +fi=(33) +3101 75025 +fi=(122) +151 225075 ++54 75025 +fi=(18) +664 75025 +fi=(122) +206 150050 +fi=(33) +2224 150050 +fi=(122) +212 75025 +fi=(10) +2496 300100 +fi=(32) +616 75025 +fi=(122) +136 150050 +fi=(32) +0 75025 +fi=(122) +151 225075 +fi=(32) +672 300 +cfn=(5514) +calls=108 -14 +* 660025 +* 175 +cfn=(5514) +calls=36 -14 +* 18925 +* 25 +fi=(122) +205 75025 +fi=(20) +970 75025 +fi=(18) +664 300100 +cob=(2) +cfi=(2) +cfn=(4490) +calls=108036 0 +* 1125375 +fi=(122) +206 150050 +fi=(33) +2224 75025 +fi=(122) +212 75025 +fi=(119) +508 300100 +cfi=(122) +cfn=(6146) +calls=108036 315 +* 3976325 +0 150050 +fi=(18) +847 300100 +fe=(121) + +fl=(37) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +fn=(5186) core::str::converts::from_utf8 +89 750125 +fi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 450075 ++12 300050 +0 1050175 +145 50 ++19 150050 ++1 300100 +fi=(10) +2689 300100 +3875 150050 +fi=(38) +222 150050 ++23 50 +-21 300050 ++17 300050 +0 150025 +241 1175400 ++1 587700 +-1 1325425 +fe=(37) +94 600100 +-94 150025 +98 600100 + +fl=(24) +fn=(5140) +cfn=(6356) measured_region +calls=1 79 +70 80501030 + +fn=(6356) +79 9 +fi=(19) +2144 1 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 1 +0 8 +fi=(26) +0 3 +fi=(19) +2144 25 +fi=(34) +1100 25 +fi=(131) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 50 +fe=(24) +91 175 +cfi=(109) +cfn=(6078) +calls=25 -53 +* 80496300 +fi=(27) +1230 50 ++1 100 +fi=(131) +491 50 +fi=(32) +631 50 +fe=(24) +91 25 +fi=(26) +-26 25 +cob=(2) +cfi=(2) +cfn=(4878) +calls=25 -65 +* 4100 +* 25 +fe=(24) ++29 8 + +fn=(5102) __rustc::__rust_alloc +41 25025 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 25025 +762 25025 +fe=(24) +16 25025 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 100100 +fi=(26) +30 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4228) +calls=46080 -31 +* 661650 +fe=(24) + +fn=(5522) +41 50175 +fi=(13) +3994 50175 +762 50175 +fe=(24) +33 50175 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 250875 +405 100350 +fi=(26) +70 100350 ++1 100350 +cob=(2) +cfi=(2) +cfn=(4460) +calls=72278 -71 +* 4826625 +fe=(24) + +fl=(45) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/schema.rs +fn=(6120) ::matches_variant +142 200200 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(96) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(96) +97 25025 +fi=(13) +3994 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) +180 25025 +0 75075 +fi=(13) +4049 25025 +fi=(96) +111 25025 ++7 100100 +fe=(45) ++33 225225 + +fn=(6102) ::variants +103 350 +fi=(14) +454 50 +fi=(73) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2454 50 +fi=(13) +3994 50 +fi=(96) +54 100 ++45 50 +fi=(13) +4149 50 +fi=(96) +97 50 +fi=(13) +3994 50 +fi=(33) +1865 50 +fi=(10) +3212 350 +fi=(47) +478 100 +fi=(32) +-17 100 +fi=(120) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/take.rs +0 50 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +440 200 +fi=(13) +4049 50 +fi=(96) +111 50 ++7 200 +fe=(45) +-10 450 + +fl=(118) +fn=(6174) ::format_scalar_to +204 525000 ++4 300000 +0 75000 +208 225000 ++7 25000 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/f64.rs +1264 25000 +886 100000 +fi=(113) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +1037 50000 +fi=(32) +611 25000 +fi=(33) +1865 50000 +fe=(118) +211 25000 +fi=(19) +2144 25000 +fi=(145) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/api.rs +50 25000 +fi=(123) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs +310 50000 ++2 50000 +118 22500 ++2 45000 ++1 45000 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +-60 22500 +fi=(123) ++16 22500 +-39 45000 ++76 67500 +fi=(43) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +219 22500 +fi=(123) +68 22500 ++20 22500 ++1 22500 +-21 22500 ++21 45000 +fe=(118) +-89 125000 +fi=(128) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/bit.rs +178 50000 +fi=(19) +2105 25000 +fi=(146) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs +121 25000 +fi=(27) +0 125000 +fi=(126) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs +292 50025 +0 50 +fi=(128) +282 50 +fi=(10) +154 25 +fi=(147) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/decimal.rs +32 50 +fi=(43) +186 25 +fi=(19) +2150 25 +fi=(147) +108 25 +fi=(126) +-54 25 +fi=(127) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs +181 100 +fi=(128) +282 49950 +fi=(10) +154 24975 +fi=(147) +32 49950 +fi=(43) +186 24975 +fi=(19) +2150 24975 +fi=(147) +108 24975 +fi=(126) +-54 24975 +fi=(127) +181 99900 ++5 50000 +fi=(126) +53 50000 +fi=(123) +310 50000 ++2 24500 +118 9375 ++2 18750 ++1 18750 +fi=(124) +-60 3350 +fi=(123) ++16 3350 +-39 6700 ++76 10050 +fi=(43) +219 3350 +fi=(123) +68 6700 ++20 3350 ++1 3350 +-21 3350 ++21 6700 +fi=(126) +225 3350 ++3 9500 +0 224775 +352 49950 +0 24975 +fi=(148) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 24975 +fi=(126) +875 24975 +456 49950 +fi=(43) +219 74925 +fi=(126) +0 24975 +fi=(43) +219 24975 +fi=(149) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/index.rs +13 24975 +fi=(113) +1057 49950 +fi=(148) +2261 24975 +fi=(126) +883 24975 +457 24975 +1381 149850 +fi=(149) +13 24975 +fi=(126) +461 49950 ++12 74925 +836 99900 +-6 74925 ++7 49950 +-7 99900 +968 24975 +fi=(10) +2728 24975 +fi=(126) +484 24975 ++13 49950 +-51 49950 ++54 24975 +fi=(123) +314 5000 +fi=(43) +-95 2250 +fi=(123) +68 2250 ++20 4500 +-88 45000 +fe=(118) +212 22500 +cfi=(37) +cfn=(5186) +calls=32400 89 +* 1215000 +fi=(27) +714 45000 +fi=(123) +0 12750 +319 38250 ++2 25500 +fi=(126) +0 11450 +fi=(124) +61 250 +fi=(123) ++16 750 +fe=(118) +212 250 +cfi=(37) +cfn=(5186) +calls=360 89 +* 11000 +fi=(27) +714 500 +fi=(123) +0 4500 +fe=(118) +212 2250 +cfi=(37) +cfn=(5186) +calls=3240 89 +* 110250 +fi=(27) +714 4500 +fi=(123) +314 5750 +fi=(43) +-95 2350 +fi=(123) +68 4700 ++20 4700 ++1 4700 +fi=(126) +225 2350 ++3 7000 +fi=(43) +-9 6025 +fi=(123) +68 12050 ++20 12050 ++1 6025 +-51 12050 ++76 18075 +-46 6025 ++20 6025 ++1 6025 +-21 6025 ++21 12050 +fi=(126) +225 6025 ++3 12675 +fi=(123) ++98 25500 +fi=(124) +61 1050 +fi=(123) ++16 525 +fi=(126) +225 1050 +fi=(10) +1096 1575 +fi=(43) +102 525 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/specialize.rs +-68 2100 +cob=(2) +cfi=(2) +cfn=(4976) +calls=756 -34 +* 9125 +fi=(10) +1096 17175 +fi=(43) +102 5725 +fi=(150) +-68 22900 +cob=(2) +cfi=(2) +cfn=(4976) +calls=8244 -34 +* 94275 +fi=(126) +236 6250 ++3 6250 +fi=(146) +-85 25000 +fe=(118) ++62 6250 +cfi=(37) +cfn=(5186) +calls=9000 89 +* 403500 +fi=(27) +714 12500 +fi=(126) +1398 74925 +535 24975 +1404 149850 ++2 49950 +0 24975 +fi=(10) +2728 24975 +fi=(126) +1088 24975 +1412 74925 +0 36050 +fi=(10) +2728 36050 +fi=(126) +1088 36050 +1412 108150 +0 174825 +533 24975 +fi=(123) +328 25500 +118 12750 ++2 25500 ++1 25500 +fi=(124) +-60 10250 +fi=(123) ++16 10250 +-39 30750 ++76 41000 +fi=(43) +219 10250 +fi=(123) +68 20500 ++20 10250 ++1 10250 +-21 10250 ++21 10250 +-51 10250 ++76 30750 +-46 10250 ++20 10250 ++1 10250 +-21 10250 ++21 20500 +fi=(126) +225 10250 ++3 20500 +fi=(27) +0 50000 +fe=(118) +221 600000 +fi=(126) ++26 37500 +fi=(43) +102 18750 +fi=(34) +1142 37500 +0 18750 +1142 18750 +fi=(19) +2144 18750 +0 18750 +2144 18750 +fi=(126) +251 56250 +fi=(34) +1142 18750 +fi=(19) +2144 12500 +fi=(126) +251 37500 +fi=(34) +1142 12500 +fi=(126) +248 18750 ++7 18750 +fi=(146) +154 37500 +fe=(118) ++62 18750 +cfi=(37) +cfn=(5186) +calls=27000 89 +* 1273000 +fi=(27) +714 37500 +fi=(43) +219 2500 +fi=(123) +68 5000 ++20 5000 ++1 2500 +-51 7500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 2500 +-51 2500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 5000 +fi=(126) +225 2500 ++3 5000 +fe=(118) + +fn=(6092) ::collect_namespaces +88 225 ++1 100 +fi=(33) +-89 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 175 +180 25 +fi=(14) +454 25 +fi=(73) +2454 25 +fe=(118) +0 50 +cfn=(6093) ::collect_namespaces'2 +calls=36 88 +0 2925 +0 25 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(118) +-85 50 ++5 150 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +2415 25 +fe=(118) +103 50 +fi=(14) +454 25 +fe=(118) +103 25 +0 50 +114 25 +cfi=(45) +cfn=(6102) +calls=36 -11 +* 1200 +fi=(33) +3101 25 ++25 25 +fe=(118) +115 25 +fi=(32) +425 50 +631 25 +fe=(118) +123 200 + +fn=(6093) +88 225 ++1 100 +fi=(33) +-89 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 175 +180 25 +fe=(118) +0 75 +fi=(14) +1663 75 +fi=(50) +180 75 +fe=(118) +-85 150 ++5 300 +0 50 +114 25 +cfi=(45) +cfn=(6102) +calls=36 -11 +* 1200 +fi=(33) +3101 25 ++25 25 +fe=(118) +115 25 +fi=(32) +425 50 +631 25 +fe=(118) +123 200 + +fn=(6118) ::write_model::<&mut core::io::cursor::Cursor>> +230 225 ++9 125 +0 50 +252 50 +0 50 +fi=(14) +454 25 +fi=(73) +2454 75 +fe=(118) +253 75 +cfi=(45) +cfn=(6120) +calls=36 142 +* 950 +* 50 +0 125 +fi=(98) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs +0 25 +fe=(118) +280 75 +cfi=(37) +cfn=(5186) +calls=36 89 +* 2000 +fi=(27) +0 50 +2177 50 +0 25 +fe=(118) +281 100 ++3 75 +fi=(99) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +124 100 +0 25 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 450 +fi=(45) +4 50 +fi=(116) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +-4 50 +fi=(14) +1663 25 +fi=(50) +180 50 +fe=(118) +325 75 ++21 200 +cfi=(121) +cfn=(6138) +calls=36 -84 +* 4400 +0 25 +fi=(27) +965 50 +fi=(18) +0 25 +fi=(33) +1865 25 +fe=(118) +350 50 +fi=(14) +1663 25 +fi=(50) +180 25 +0 475 +fi=(45) +4 25 +fe=(118) +381 25 +0 25 +273 50 +fi=(43) +-89 50 ++2 50 +fi=(40) +743 75 +fe=(118) +274 25 +fi=(129) /home/bailey/github/polyxml-perf-old/crates/polyxml-core/src/value.rs +59 25 +fe=(118) +383 25 +fi=(40) +743 75 +0 25 +743 50 +fi=(33) +0 25 +fe=(118) +389 125 +0 50 +413 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25075 +fi=(14) +1663 25000 +fi=(50) +180 25000 +fi=(28) +2415 25000 +fe=(118) +415 75000 +fi=(40) +743 50000 +fi=(14) +454 25000 +fi=(40) +743 50000 +fi=(23) +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fi=(73) +2454 25000 +fe=(118) +465 200000 +cfn=(6119) ::write_model::<&mut core::io::cursor::Cursor>>'2 +calls=36000 230 +* 79784625 +* 25000 +fi=(27) +2177 50000 +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +fi=(98) +350 50 +fe=(118) +502 175 +cfi=(121) +cfn=(6138) +calls=36 262 +* 3800 +0 25 +fi=(27) +965 50 +fe=(118) +506 200 +0 25 +505 25 ++1 25 +fi=(18) +847 50 +fi=(23) +0 25 +fi=(18) +847 75 +fe=(118) + +fn=(6119) +230 225000 ++9 125000 +0 50000 +252 50000 +0 50000 +fi=(14) +454 25000 +fi=(73) +2454 75000 +fe=(118) +253 75000 +cfi=(45) +cfn=(6120) +calls=36000 142 +* 950000 +* 50000 +0 125000 +fi=(98) +0 25000 +fe=(118) +280 75000 +cfi=(37) +cfn=(5186) +calls=36000 89 +* 1475000 +fi=(27) +0 50000 +2177 50000 +0 25000 +fe=(118) +281 100000 ++3 75000 +fi=(99) +124 100000 +0 25000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 450000 +fi=(45) +4 150000 +fi=(116) +-4 150000 +fi=(14) +1663 75000 +fi=(50) +180 100000 +0 25000 +fe=(118) +273 50000 +fi=(43) +-89 50000 ++2 50000 +fi=(40) +743 75000 +fe=(118) +274 25000 +fi=(129) +59 25000 +fe=(118) +307 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(118) +308 50000 +cfi=(37) +cfn=(5186) +calls=36000 89 +* 1225000 +fi=(27) +0 50000 +2177 50000 +0 25000 +fe=(118) +281 25000 ++28 25000 ++3 75000 +-3 25000 +0 25000 +314 100000 ++1 75000 +cfn=(6174) +calls=36000 204 +* 2728250 +* 50000 +-91 100000 +fi=(98) +350 25000 +fe=(118) +-33 150000 +cfi=(99) +cfn=(6182) ::push_attribute::<(&str, &str)> +calls=36000 -61 +* 16322000 +fi=(18) +847 75000 +fe=(118) +325 75000 ++21 200000 +cfi=(121) +cfn=(6138) +calls=36000 -84 +* 5319400 +0 25000 +fi=(27) +965 50000 +fi=(18) +0 25000 +fi=(33) +1865 25000 +fe=(118) +350 50000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 475000 +fi=(45) +4 75000 +fe=(118) +381 75000 +0 50000 +273 100000 +fi=(43) +-89 100000 ++2 100000 +fi=(40) +743 150000 +fe=(118) +274 50000 +fi=(129) +59 50000 +fe=(118) +383 50000 +fi=(40) +743 150000 +0 50000 +743 100000 +fi=(33) +0 50000 +fe=(118) +389 250000 +fi=(40) +0 50000 +fe=(118) +391 200000 ++1 150000 +cfn=(6174) +calls=72000 204 +* 7846350 +* 150000 +0 50000 +224 200000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(118) +394 100000 +cfi=(37) +cfn=(5186) +calls=72000 89 +* 3075000 +0 200000 +fi=(27) +2177 100000 +0 50000 +fe=(118) +281 50000 +395 50000 ++3 150000 ++4 400000 +cfi=(121) +cfn=(6138) +calls=72000 262 +* 8820325 +fi=(27) +965 100000 +fi=(105) +108 200000 +cfn=(6220) +calls=72000 +93 +* 5613050 +fi=(99) +564 250000 +fe=(118) +405 200000 +cfi=(121) +cfn=(6138) +calls=72000 262 +* 4466075 +fi=(27) +965 100000 +fe=(118) +408 350000 +cfi=(121) +cfn=(6138) +calls=72000 262 +* 7619175 +fi=(27) +965 100000 +fe=(118) +410 50000 +fi=(18) +847 100000 +fi=(27) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fi=(98) +350 50000 +fe=(118) +502 175000 +cfi=(121) +cfn=(6138) +calls=36000 262 +* 3800000 +0 25000 +fi=(27) +965 50000 +fe=(118) +506 200000 +0 25000 +505 25000 ++1 25000 +fi=(18) +847 50000 +fi=(23) +0 25000 +fi=(18) +847 75000 +fe=(118) + +fn=(6080) +172 350 +cfi=(6) +cfn=(5100) +calls=36 0 +* 25 +fi=(23) +-42 75 +cfi=(24) +cfn=(5102) +calls=36 -89 +* 11950 +fi=(32) +470 50 +fi=(119) +102 100 +fe=(118) ++79 50 +fi=(40) +0 25 +743 25 +0 25 +fi=(121) +124 75 +fe=(118) ++62 50 +0 50 +188 75 +cfn=(6090) ::build +calls=36 23 +* 6525 +fi=(40) +743 75 +0 25 +743 75 +0 50 +fe=(118) +191 225 +cfn=(6118) +calls=36 +39 +* 80475575 +* 25 +fi=(27) +2177 50 +fe=(118) +201 125 +fi=(18) +847 125 +fe=(118) +202 225 + +fn=(6090) +23 250 +fi=(33) +462 100 +fe=(118) +28 50 +cfn=(6092) +calls=36 +60 +* 5675 +fi=(33) +3126 25 +fe=(118) +30 25 +fi=(40) +709 50 +fe=(118) +0 25 +31 25 +fi=(32) +425 50 +631 25 +fe=(118) +86 225 + +fl=(95) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +fn=(6194) >::from +376 75000 ++2 50000 ++1 50000 +fi=(105) +168 50000 +cfn=(6196) +calls=36000 +33 +* 1722500 +* 25000 +fe=(95) +377 25000 ++4 100000 + +fl=(99) +fn=(6182) +256 175000 +fi=(98) ++28 75000 +fi=(32) +611 25000 +fi=(125) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/char/methods.rs +2558 25000 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1440 25000 +fi=(33) +2224 75000 +fi=(143) +781 50000 +cfi=(95) +cfn=(6194) +calls=36000 376 +* 2097500 +fe=(99) +261 75000 +cfn=(6204) ::push_attr +calls=36000 +41 +* 5899500 ++1 200000 +fi=(98) ++23 50000 +fi=(47) +478 25000 +fi=(32) +0 25000 +461 25000 +0 100000 +cfi=(6) +cfn=(5100) +calls=36000 0 +0 25000 +0 25000 +fi=(23) +130 75000 +cfi=(24) +cfn=(5102) +calls=36000 -89 +* 950000 +fi=(32) +470 50000 +fi=(36) +0 25000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=36000 0 +* 375000 +* 50000 +fi=(98) +286 75000 +fi=(32) +672 175000 +cfn=(5514) +calls=36000 -14 +* 5375000 +* 75000 +fe=(99) + +fn=(6204) +302 225000 +fi=(98) +-18 75000 +fi=(33) +1461 50000 +fi=(101) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +222 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +0 25000 +fi=(20) +970 25000 +fi=(18) +573 75000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=36000 0 +* 450000 +fi=(33) +2986 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +-59 25000 +fi=(18) +-38 25000 +fi=(33) +2986 50000 +fi=(98) +0 75000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +fi=(20) +970 50000 +fi=(18) +573 50000 +cob=(2) +cfi=(2) +cfn=(4490) +calls=36000 0 +* 449500 +fi=(33) +2986 50000 +fi=(32) +764 25000 +-94 25000 +fi=(125) +2558 25000 +fi=(39) +1440 25000 +fi=(33) +2224 25000 +fi=(18) +847 75000 +fe=(99) +309 200000 +fi=(32) +672 100000 +cfn=(5514) +calls=36000 -14 +* 3125000 +-56 25000 +fi=(33) +3101 50000 +fe=(99) + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4128) +calls=1 0 +0 80501030 + +totals: 80501030 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-annotated.txt new file mode 100644 index 0000000..3878048 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-annotated.txt @@ -0,0 +1,209 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/selected-diagnostics/read-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 89724906 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics read 1000 25 instructions (PID 394741, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +296,585,254 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +21,680,675 ( 7.31%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +13,926,225 ( 4.70%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +11,858,578 ( 4.00%) ???:0x00000000000b2400 [/usr/lib/x86_64-linux-gnu/libc.so.6] +10,868,100 ( 3.66%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +10,352,875 ( 3.49%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 9,477,175 ( 3.20%) crates/polyxml-core/src/parser.rs:::parse_sub_tree::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 8,900,000 ( 3.00%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs: as core::hash::Hasher>::write [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 7,805,073 ( 2.63%) ???:0x00000000000b20e0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 6,602,200 ( 2.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 6,401,100 ( 2.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::next [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 5,426,700 ( 1.83%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs:::feed [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 5,127,950 ( 1.73%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,625,000 ( 1.56%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs:::hash_one::<&[u8]> + 4,403,350 ( 1.48%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 4,058,539 ( 1.37%) ???:0x00000000001972a0 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 3,650,000 ( 1.23%) crates/polyxml-core/src/converters.rs:::parse_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 3,275,600 ( 1.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 3,150,700 ( 1.06%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 3,001,875 ( 1.01%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 3,000,000 ( 1.01%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::hash_one::<&[u8]> + 2,825,000 ( 0.95%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::find:: + 2,801,425 ( 0.94%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::parse_sub_tree::<&[u8]> + 2,625,750 ( 0.89%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:core::ptr::drop_glue::> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,550,000 ( 0.86%) crates/polyxml-core/src/parser.rs:polyxml::parser::is_nil_element [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,475,825 ( 0.83%) crates/polyxml-core/src/parser.rs:polyxml::parser::namespace_scope [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,475,550 ( 0.83%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_sub_tree::<&[u8]> + 2,414,886 ( 0.81%) ???:0x00000000000b0f70 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 2,375,000 ( 0.80%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::hash_one::<&[u8]> + 2,325,000 ( 0.78%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:::check_for_duplicates [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,200,000 ( 0.74%) /rust/deps/hashbrown-0.17.1/src/raw.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,175,000 ( 0.73%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::next + 2,076,050 ( 0.70%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_start + 2,025,675 ( 0.68%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_end [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,025,675 ( 0.68%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_start [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 2,001,075 ( 0.67%) crates/polyxml-core/src/parser.rs:::parse_attributes [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,950,800 ( 0.66%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,948,250 ( 0.66%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,900,350 ( 0.64%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::next + 1,800,000 ( 0.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::find:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,583,400 ( 0.53%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs:::parse_scalar + 1,525,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::parse_sub_tree::<&[u8]> + 1,500,150 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 1,500,000 ( 0.51%) /rust/deps/hashbrown-0.17.1/src/map.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 1,500,000 ( 0.51%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs:::hash_one::<&[u8]> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,489,425 ( 0.50%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,465,250 ( 0.49%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 1,366,800 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::next + 1,357,775 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,350,275 ( 0.46%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,350,000 ( 0.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::grow_one [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,275,425 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs:::emit_end + 1,226,475 ( 0.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::finish + 1,225,425 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:; 8]>>::from_elem + 1,200,400 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 1,200,000 ( 0.40%) crates/polyxml-core/src/parser.rs:polyxml::parser::record_content_token [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,199,850 ( 0.40%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 1,151,775 ( 0.39%) crates/polyxml-core/src/parser.rs:::finish [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 1,150,300 ( 0.39%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:::feed + 1,075,300 ( 0.36%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 1,050,400 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 1,050,300 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:::feed + 1,050,300 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_end + 1,050,150 ( 0.35%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_sub_tree::<&[u8]> + 1,000,000 ( 0.34%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::parse_sub_tree::<&[u8]> + 975,000 ( 0.33%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 950,100 ( 0.32%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::next + 900,750 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_sub_tree::<&[u8]> + 900,525 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 900,300 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 900,275 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_end + 900,100 ( 0.30%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 897,350 ( 0.30%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_scalar + 850,150 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 850,000 ( 0.29%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs:::local_name [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 850,000 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::parse_sub_tree::<&[u8]> + 850,000 ( 0.29%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs:::local_name + 800,575 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_start + 800,250 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 800,100 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs:::parse_sub_tree::<&[u8]> + 800,000 ( 0.27%) crates/polyxml-core/src/parser.rs:::new [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 775,475 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::finish + 775,000 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::try_allocate_in [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 750,250 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 750,250 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::emit_start + 750,000 ( 0.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::next + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs: as core::hash::Hasher>::write + 750,000 ( 0.25%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs:::hash_one::<&[u8]> + 700,700 ( 0.24%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]>>::from_elem [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 700,250 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 700,225 ( 0.24%) crates/polyxml-core/src/parser.rs:::push_list_item [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 700,000 ( 0.24%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 675,675 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter + 675,225 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs:::emit_start + 675,150 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 675,000 ( 0.23%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::unescape [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 650,125 ( 0.22%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::namespace_scope + 608,450 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::parse_scalar + 603,525 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 600,600 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,200 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 600,150 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:core::ptr::drop_glue::> + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 600,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:polyxml::parser::is_nil_element + 575,050 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs:::parse_sub_tree::<&[u8]> + 575,000 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs:::parse_scalar + 550,550 ( 0.19%) crates/polyxml-core/src/parser.rs:polyxml::parser::resolve_record_schema [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 550,550 ( 0.19%) crates/polyxml-core/src/schema.rs:polyxml::schema::validate_content [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 550,350 ( 0.19%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::finish + 525,175 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::emit_end + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::check_for_duplicates + 525,000 ( 0.18%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::check_for_duplicates + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs:__rustc::__rust_alloc + 501,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_alloc + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs:::try_fast_path:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 500,000 ( 0.17%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs:::emit_text [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 500,000 ( 0.17%) /rust/deps/hashbrown-0.17.1/src/lib.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs: as core::hash::Hasher>::write + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::map_or::<&str, >::from::{closure#0}> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 500,000 ( 0.17%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::parse_attributes + 500,000 ( 0.17%) crates/polyxml-core/src/parser.rs:polyxml::parser::parse_field_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:>; 4]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 475,475 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:; 8]> as core::ops::drop::Drop>::drop [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 466,875 ( 0.16%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 452,375 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 450,150 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs:::emit_end + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 450,150 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::emit_start + 450,100 ( 0.15%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs:::parse_scalar + 450,050 ( 0.15%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr_raw::find_avx2 + 425,850 ( 0.14%) ???:0x00000000000b2300 [/usr/lib/x86_64-linux-gnu/libc.so.6] + 422,350 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 + 419,500 ( 0.14%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs:::parse_scalar + 400,400 ( 0.14%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs:> as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 400,300 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,125 ( 0.13%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs:memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 + 400,100 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::feed + 400,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/collections/hash/map.rs:::parse_sub_tree::<&[u8]> + 377,250 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 375,425 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_start + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs:::parse_attributes + 375,125 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs:::emit_start + 375,000 ( 0.13%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::next + 350,100 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::feed + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::push_mut [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs: as core::hash::Hasher>::write + 350,000 ( 0.12%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 325,050 ( 0.11%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:::parse_sub_tree::<&[u8]> + 300,300 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::into_boxed_slice [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 300,200 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::finish + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:<&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,100 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,075 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::namespace_scope + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,050 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs:::emit_end + 300,025 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::parse_sub_tree::<&[u8]> + 300,025 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::parse_sub_tree::<&[u8]> + 300,000 ( 0.10%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::name + 300,000 ( 0.10%) /rust/deps/hashbrown-0.17.1/src/control/tag.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs:polyxml::parser::is_nil_element + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>::read_event_impl::<&mut alloc::vec::Vec> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:, usize, std::hash::random::RandomState>>::get::<[u8]> + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:::check_for_duplicates + 300,000 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs:::name + 291,750 ( 0.10%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs:::next + 275,050 ( 0.09%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::parse_attributes + 250,500 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs:__rustc::__rust_alloc + 250,500 ( 0.08%) benchmarks/rust-runtime-investigation/target/selected/src/main.rs:__rustc::__rust_alloc [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 250,475 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::finish + 250,050 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs:::parse_scalar + 250,000 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs:::parse_scalar + 250,000 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::parse_sub_tree::<&[u8]> + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs:::parse_attributes + 250,000 ( 0.08%) /rust/deps/hashbrown-0.17.1/src/raw.rs:::parse_attributes + 250,000 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::parse_scalar + 226,525 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 225,225 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:polyxml::parser::resolve_record_schema + 225,100 ( 0.08%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs:::push_list_item + 225,075 ( 0.08%) crates/polyxml-core/src/schema.rs:::finish + 225,050 ( 0.08%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::emit_end + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-valgrind.txt new file mode 100644 index 0000000..3091a19 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-valgrind.txt @@ -0,0 +1,12 @@ +==394741== Callgrind, a call-graph generating cache profiler +==394741== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==394741== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==394741== Command: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics read 1000 25 instructions +==394741== Parent PID: 388927 +==394741== +==394741== For interactive control, run 'callgrind_control -h'. +==394741== +==394741== Events : Ir +==394741== Collected : 296585254 +==394741== +==394741== I refs: 296,585,254 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000.callgrind new file mode 100644 index 0000000..b5c7286 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000.callgrind @@ -0,0 +1,3680 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 394741 +cmd: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics read 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 89724906 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 296585254 + + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4508) 0x00000000000b20e0 +0 4946685 +cfn=(4942) 0x00000000000b0f70 +calls=73313 0 +0 1086761 +0 2459238 +cfn=(4942) +calls=35010 0 +0 548102 +0 399150 + +fn=(4330) 0x00000000000b08d0 +0 120120 + +fn=(4488) 0x0000000000197a00 +0 21680675 + +fn=(4162) 0x000000000002a580 +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4176) main +calls=1 0 +0 296585254 + +fn=(4232) 0x00000000000b2400 +0 10553314 +cfn=(4942) +calls=35955 0 +0 780023 +0 1272808 +cfn=(4330) +calls=32761 0 +0 117485 +0 8432 +cfn=(4330) +calls=799 0 +0 2635 +0 24024 + +fn=(5752) 0x00000000001972a0 +0 4058539 + +fn=(4226) malloc +0 796400 +cfn=(4232) +calls=73729 0 +0 12746428 +0 3606950 + +fn=(4460) 0x00000000000b4180 +0 1109825 +cfn=(4232) +calls=64 0 +0 12293 +0 325500 +cfn=(4502) 0x00000000000b2300 +calls=37042 0 +0 3506272 +0 25225 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=63 0 +0 325 +0 150 +cfn=(4502) +calls=63 0 +0 2925 +0 4550 + +fn=(4128) (below main) +cfn=(4162) +calls=1 0 +0 296585254 + +fn=(4458) realloc +0 1670225 +cfn=(4460) +calls=38415 0 +0 4987065 +0 278025 + +fn=(4942) +0 2414886 + +fn=(4502) +0 300600 +cfn=(4508) +calls=37105 0 +0 3083347 +0 125250 + +fn=(4868) free +0 597300 +cfn=(4508) +calls=73670 0 +0 6356589 +0 4530650 + +ob=(3) +fl=(3) +fn=(4486) +0 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=109 0 +0 275 + +ob=(6) +fl=(108) /home/bailey/github/PolyXML/crates/polyxml-core/src/converters.rs +fn=(5790) ::parse_scalar +28 1275000 ++5 1275000 +fi=(111) /home/bailey/github/PolyXML/crates/polyxml-core/src/lib.rs +-33 25000 +fi=(76) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/mod.rs +199 25000 +fi=(56) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/macros/mod.rs +434 50000 +0 25000 +434 75000 +fi=(76) +0 25000 +fe=(108) +132 75000 +cfi=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +cfn=(5180) core::str::converts::from_utf8 +calls=37000 -43 +* 1961250 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +0 50000 +2177 50000 +0 25000 +fi=(76) +199 25000 +0 75000 +fi=(56) +434 75000 +fi=(111) +0 25000 +fi=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +435 125000 +cfn=(5898) ::try_allocate_in +calls=37000 +12 +* 11703953 +0 25000 +435 75000 ++1 25000 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs ++16 50000 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 330000 +fe=(108) +133 100000 +0 50000 +209 225000 +0 50000 +209 450000 +fi=(56) +434 150000 +fi=(76) +0 25000 +fi=(56) +434 175000 +fi=(112) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/parse.rs +175 100000 +fi=(56) +0 25000 +fi=(109) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-integer-1.0.6/src/algorithm.rs +199 150000 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +0 50000 +fi=(113) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/iterator.rs +252 100000 +0 50000 +252 25000 +fi=(109) +677 25000 ++10 25000 +0 75000 +411 50000 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +2689 25000 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +39 50000 +fi=(109) +411 94500 +fi=(10) +2689 47250 +fi=(124) +39 94500 +fi=(110) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/noskip.rs +270 72250 +fi=(141) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 72250 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +132 72250 +fi=(141) +2189 72250 +fi=(44) +184 216750 +0 25000 +fe=(108) +154 75000 +fi=(44) ++30 50000 +fi=(112) +872 205600 +fi=(10) +2689 102800 +fi=(124) +39 205600 +fi=(10) +2728 155600 +fi=(112) +566 77800 +fi=(10) +2652 77800 +fi=(110) +144 77800 +fi=(44) ++40 155600 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +2105 25000 +fi=(112) +616 25000 +0 75000 +fi=(44) +380 50000 +fi=(113) +252 75000 +fi=(44) +-68 50000 +0 25000 +fi=(112) +872 50000 +fi=(10) +2689 25000 +fi=(124) +39 50000 +fi=(112) +872 50000 +fi=(10) +2689 25000 +fi=(124) +39 50000 +fi=(10) +2728 100000 +fi=(112) +623 50000 +fi=(10) +2652 50000 +fi=(110) +144 50000 +fi=(44) ++40 100000 +0 50000 +90 50000 +fi=(112) +616 250000 +-48 100000 +fi=(44) +184 50000 +fi=(110) +0 50000 +fi=(112) +666 50000 +fi=(44) +0 25000 +fi=(112) +747 50000 +0 50000 +855 50000 +216 300000 ++51 25000 +cfi=(114) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/number.rs +cfn=(5918) ::try_fast_path:: +calls=37000 45 +* 675000 +* 50000 +0 25000 +fe=(108) +164 75000 + +fl=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +fn=(5718) ::local_name +141 250000 ++69 250000 +fi=(10) +1096 100000 +fi=(44) +90 50000 +fi=(102) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/memchr.rs +-62 100000 ++13 100000 +-41 100000 +42 200000 ++4 100000 +-5 250000 +fi=(54) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/const_ptr.rs +-41 50000 +fe=(103) +143 350000 + +fl=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +fn=(6140) >>::drop_slow +2138 75 ++6 25 +fi=(18) +842 25 ++5 25 +cfi=(55) /rust/deps/hashbrown-0.17.1/src/raw.rs +cfn=(6142) as core::ops::drop::Drop>::drop +calls=37 3486 +* 450 +fi=(119) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/rc.rs +3277 25 +fe=(59) +3392 25 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +4049 25 +fe=(59) +3544 25 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +175 175 +cfi=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +cfn=(5682) __rustc::__rust_dealloc +calls=37 65 +* 850 +fe=(59) + +fl=(92) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/mod.rs +fn=(5702) ::find:: +1497 1100000 +fi=(10) +1096 200000 +fi=(44) +90 100000 +fi=(102) +-62 200000 ++13 200000 +-41 200000 +42 850000 ++4 425000 +-5 950000 +fe=(92) +1499 700000 + +fl=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +fn=(5814) >::push_mut +1027 125000 ++2 25000 ++3 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +-62 50000 +fi=(18) +1963 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fe=(33) +1038 50000 ++4 100000 + +fn=(5964) >>::into_boxed_slice +1723 100100 +fi=(32) +616 25025 +fe=(33) +1598 75075 +fi=(32) +832 25025 +fi=(10) +1401 25025 +fi=(32) +839 50050 +fi=(10) +1401 25025 +fi=(23) +228 75075 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/src/main.rs +cfn=(5538) __rustc::__rust_realloc +calls=37037 41 +* 7260022 +fi=(27) +965 50050 +fe=(33) +1731 125125 + +fl=(38) +fn=(5180) +89 1125250 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 675150 ++12 450100 +0 1575350 +164 225050 ++1 450100 +fi=(10) +2689 450100 +3875 225050 +fi=(39) +222 225050 ++2 450100 ++17 450100 +0 225050 +241 3590050 ++1 1795025 +-1 3815100 +fe=(38) +94 900200 +-94 225050 +98 900200 + +fl=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +fn=(5710) >::map_or::<&str, >::from::{closure#0}> +1222 100000 ++5 200000 ++4 200000 + +fl=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +fn=(5778) quick_xml::escape::unescape +236 250000 ++52 25000 +fi=(54) +473 75000 +0 25000 +fi=(13) +3994 50000 +fi=(78) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/memchr.rs +153 125000 +cfi=(84) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/x86_64/avx2/memchr.rs +cfn=(5490) memchr::arch::x86_64::memchr::memchr2_raw::find_avx2 +calls=37000 659 +* 1053000 +fi=(41) +2869 50000 +fe=(107) +321 50000 +fi=(91) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/traits.rs +0 25000 +fe=(107) +327 100000 +0 25000 +238 225000 + +fl=(6) +fn=(4176) +cfi=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +cfn=(4178) std::rt::lang_start_internal +calls=1 152 +0 296585254 + +fn=(5090) __rustc::__rust_no_alloc_shim_is_unstable_v2 +0 125250 + +fn=(4126) (below main) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 296585254 + +fl=(85) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/buffered_reader.rs +fn=(5502) <&[u8] as quick_xml::reader::XmlSource<&mut alloc::vec::Vec>>::read_with:: +211 1800600 +fi=(33) +3101 150050 +1032 300100 ++1 100 +cfi=(32) +cfn=(5506) >::grow_one +calls=74 186 +* 4800 +fi=(32) +611 150050 +fi=(18) +1963 150050 +fi=(33) +1038 450150 +fi=(76) +137 150050 +fe=(85) ++86 150050 +0 450150 +232 450150 +cfi=(87) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/parser/element.rs +cfn=(5514) ::feed +calls=222074 57 +* 14181000 +* 300100 +0 150050 +233 450150 +fi=(10) +1092 150050 +fi=(32) +616 150050 +fi=(33) +1461 150050 +fi=(10) +2689 150050 +fi=(32) +764 150050 +-94 150050 +fi=(33) +2981 300000 +0 150050 +fi=(20) +970 150050 +fi=(18) +573 750250 +cob=(2) +cfi=(2) +cfn=(4488) +calls=222074 0 +* 2200650 +* 300100 +fi=(33) +2986 450150 +fi=(44) +90 150050 +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/io/impls.rs +389 450150 +fe=(85) +239 600200 +fi=(44) +544 450150 +90 300100 +fe=(85) +240 300100 +cfi=(38) +cfn=(5180) +calls=222074 89 +* 12090575 +fi=(27) +0 300100 +2177 300100 +fe=(85) +253 1200400 +0 150050 +240 600200 +fi=(33) +0 50 +fi=(32) +672 300 +cfn=(5530) >::reserve::do_reserve_and_handle:: +calls=74 -14 +* 6600 +* 100 +fi=(33) +3101 50 +2981 50 +fe=(85) + +fl=(98) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.16.2/src/lib.rs +fn=(5632) ; 8]>>::from_elem +2052 250250 ++1 50050 +856 25025 +fi=(18) +-9 25025 +fi=(19) +2144 25025 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 25025 +fe=(98) +0 25025 +fi=(41) +2274 50050 ++2 25025 +fi=(18) +1963 400400 +fi=(19) +2144 25025 +fi=(34) +1100 25025 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fi=(41) +2276 25000 +fi=(18) +1963 400000 +fi=(19) +2144 25000 +fi=(34) +1100 25000 +fe=(98) +2615 50050 +2067 75075 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 ++2 225225 + +fn=(5958) ; 8]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(5984) >; 4]> as core::ops::drop::Drop>::drop +2373 200200 +1082 50050 +2375 25025 +fi=(23) +0 25025 +fi=(18) +847 50050 +fe=(98) +2382 200200 + +fn=(5994) >; 4]>>::resize_with::<::push_list_item::{closure#0}> +1841 200 +1082 75 +-30 25 +0 25 +1846 75 +1082 50 +-17 25 +0 25 +1358 75 +0 50 +1230 50 +fi=(20) +970 25 +fi=(18) +1963 100 +fe=(98) +1237 25 +fi=(19) +2144 25 +fi=(34) +1100 50 +fi=(74) /home/bailey/github/PolyXML/crates/polyxml-core/src/parser.rs +70 25 +fe=(98) +1082 50 +1217 25 +1856 200 + +fn=(6132) >; 4]> as core::ops::drop::Drop>::drop +2483 250 ++10 50 +-8 200 + +fl=(74) +fn=(5578) ::check_root +343 200 ++1 50 ++14 25 ++1 200 + +fn=(5692) polyxml::parser::record_content_token +1123 525000 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +454 75000 +fi=(41) +634 75000 +fe=(74) +1128 75000 ++8 600000 + +fn=(5598) polyxml::parser::namespace_scope +174 525175 ++1 75025 +fi=(101) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs +0 75025 +fi=(100) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +272 75025 +fe=(74) +-96 975325 +0 75025 +fi=(99) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/fuse.rs +403 225075 +cfi=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +cfn=(5600) ::next +calls=111037 601 +* 12009850 +* 75000 +cfi=(94) +cfn=(5600) +calls=37000 601 +* 1350000 +fi=(95) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/flatten.rs +855 300075 +fi=(41) +-90 50000 +fi=(95) ++90 200050 ++1 150000 +fi=(77) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/cmp.rs +21 50000 +fi=(76) +2635 25000 +fi=(18) +847 75000 +fi=(96) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/collections/hash/map.rs +0 75025 +fe=(74) +187 75025 +cfi=(18) +cfn=(5612) core::ptr::drop_glue::> +calls=111037 847 +* 2300450 ++1 75025 +fi=(41) +1162 150050 +fi=(13) +4029 75025 +fi=(59) +2434 75025 +fe=(74) +189 675225 + +fn=(5892) polyxml::parser::parse_field_scalar +137 150000 ++5 50000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +151 150000 +cfi=(108) +cfn=(5790) +calls=74000 28 +* 21578803 ++1 150000 + +fn=(5618) polyxml::parser::resolve_record_schema +220 200200 +fi=(14) +454 25025 +fe=(74) +225 50050 +fi=(14) +454 25025 +fi=(13) +3994 25025 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) +3101 50050 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fi=(33) +3126 25025 +fe=(74) +225 25025 +fi=(13) +4029 25025 +fi=(59) +2434 25025 +fe=(74) +226 25025 +0 25025 +274 225225 + +fn=(5990) ::push_list_item +67 175000 +fi=(98) +1082 75000 +-30 25000 +-15 25000 +fe=(74) +68 25000 +-68 24975 +fi=(98) +1082 24975 +-17 24975 +fi=(44) +195 50000 +fi=(98) +1082 25000 +-17 25000 +fe=(74) +0 25 +68 50 +fi=(14) +454 25 +fi=(33) +3101 25 +fe=(74) +70 50 +cfi=(98) +cfn=(5994) +calls=37 1841 +* 1200 +-70 25 +fi=(98) +1082 100 +-17 50 +fe=(74) +72 25000 +fi=(44) +197 50000 +fe=(74) +73 75000 ++1 199800 +fi=(33) +1029 24975 ++3 49950 ++1 450 +cfi=(32) +cfn=(6010) >::grow_one +calls=333 186 +* 46350 +fi=(32) +611 24975 +fi=(20) +970 24975 +fi=(18) +1963 199800 +fi=(33) +1038 74925 +fi=(23) +128 25 +cfi=(6) +cfn=(5090) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5092) __rustc::__rust_alloc +calls=37 -89 +* 1050 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +251 50 +fe=(74) +75 225 +fi=(18) +847 50 +fe=(74) +75 75 ++3 175000 + +fn=(5588) ::parse_sub_tree::<&[u8]> +410 350 +cfi=(6) +cfn=(5090) +calls=37 0 +* 25 +fi=(23) +130 75 +cfi=(24) +cfn=(5092) +calls=37 -89 +* 3725 +fi=(32) +470 50 +fi=(33) +969 75 +fi=(23) +128 25 +cfi=(6) +cfn=(5090) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5092) +calls=37 -89 +* 950 +fi=(28) +251 50 +fe=(74) +418 100 +cfn=(5598) +calls=37 174 +* 3000 +* 25 +fi=(33) +1196 125 +fe=(74) +420 75 +cfn=(5618) +calls=37 220 +* 1050 +fi=(27) +2177 25 +0 25 +2177 50 +fi=(41) +634 25 +fi=(33) +3101 25 +fe=(74) +38 25 ++1 100 +cfi=(98) +cfn=(5632) +calls=37 2052 +* 3225 +-7 25 ++9 75 +-4 150 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 -37 +* 1925 +* 175 +422 75 +cfn=(5636) ::parse_attributes +calls=37 997 +* 3225 +fi=(27) +2177 50 +fe=(74) +0 75 +423 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1029 25 ++3 50 +fi=(20) +-62 75 +fi=(18) +1963 50 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fi=(33) +1038 50 +462 725 +3082 200000 +fi=(85) +412 800000 +cfi=(75) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/mod.rs +cfn=(5468) >::read_event_impl::<&mut alloc::vec::Vec> +calls=296000 1006 +* 85032514 +* 100 +cfi=(75) +cfn=(5468) +calls=37 1006 +* 24575 +fe=(74) ++20 1000125 +0 200025 +432 600075 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fi=(32) +611 75000 +fi=(76) +282 150000 +fe=(74) +434 150000 +cfn=(5598) +calls=111000 174 +* 19808500 +0 150000 +fi=(33) +1029 75000 ++3 150000 ++1 50 +cfi=(32) +cfn=(5684) >::grow_one +calls=37 186 +* 20993 +fi=(32) +611 75000 +fi=(18) +1963 75000 +fi=(33) +1038 150000 +fe=(74) +435 150000 +784 100000 +fi=(101) +350 100000 +fi=(54) +871 50000 +fi=(33) +3126 50000 +fi=(13) +3994 100000 +fe=(74) +787 50000 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fi=(33) +0 75025 +fi=(13) +4049 75025 +fi=(59) +2868 75025 +fe=(74) +878 150050 +fi=(33) +3101 75025 ++25 75025 +fe=(74) +882 75025 +0 75000 +fi=(41) +634 150000 +fi=(33) +3126 150000 +fi=(76) +282 150000 +fi=(33) +1904 75000 +fi=(76) +305 150000 +fi=(32) +611 150000 +fi=(76) +305 225000 +fi=(14) +454 75000 +fi=(59) +2454 75000 +fe=(74) +441 150000 +cfn=(5692) +calls=111000 1123 +* 1350000 +fi=(33) +3126 75000 +fe=(74) +447 75000 +fi=(78) +153 150000 +cfn=(5840) memchr::arch::x86_64::memchr::memchr_raw::find_avx2 +calls=73999 -75 +* 3000300 +fi=(41) +2869 100000 +fe=(74) +0 75025 +909 300100 ++42 50050 +fi=(33) +2877 50000 +fi=(54) +871 50000 +fi=(18) +1755 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(101) +350 50000 +fi=(103) +210 75000 +cfi=(92) +cfn=(5702) +calls=37000 1497 +* 1200000 ++62 175000 +cfi=(41) +cfn=(5710) +calls=37000 1222 +* 125000 +fe=(74) +0 50000 +fi=(11) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/mem/mod.rs +975 100000 ++1 25000 +fe=(74) +-21 125000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +* 75000 +cfn=(5924) ::finish +calls=37000 80 +* 27532831 +fi=(27) +2177 50000 +0 200000 +2177 50000 +fe=(74) +955 200000 +fi=(33) +1904 25000 +fi=(76) +305 50000 +fi=(32) +611 25000 +fi=(76) +305 75000 +fe=(74) +958 75000 +fi=(76) +305 100000 +fi=(32) +611 50000 +fi=(76) +305 150000 +fi=(14) +454 50000 +fe=(74) +911 100000 +fi=(41) +634 50000 +fe=(74) +802 50000 +975 50 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99950 +0 50000 +fi=(20) +970 50000 +fi=(18) +573 150000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +fi=(33) +2986 150000 +1865 100000 +fi=(44) +238 100000 +fi=(32) +611 50000 +fi=(44) +238 150000 +fe=(74) +915 350000 +fi=(33) +3101 75000 +fe=(74) +464 150000 +fi=(100) +211 150000 +cfi=(101) +cfn=(5696) ::name +calls=111000 0 +* 775000 +* 150000 +fi=(103) +-1 225000 +cfi=(92) +cfn=(5702) +calls=111000 1497 +* 3725000 ++62 525000 +cfi=(41) +cfn=(5710) +calls=111000 1222 +* 375000 +fe=(74) +0 150000 +471 150000 +cfn=(5712) polyxml::parser::is_nil_element +calls=111000 156 +* 20683500 +fi=(33) +1865 75000 +fi=(76) +282 150000 +fe=(74) +0 75000 +fi=(32) +611 75000 +fi=(76) +282 75000 +fi=(14) +454 75000 +fi=(13) +4029 75000 +fi=(59) +2434 75000 +fe=(74) +473 75000 +fi=(59) +2438 75000 +320 75000 +fi=(96) +1039 300000 +cfi=(55) +cfn=(5736) , usize, std::hash::random::RandomState>>::get::<[u8]> +calls=111000 1337 +* 19848000 +fe=(74) +474 150000 +0 75000 +474 75000 +fi=(33) +1865 75000 +fi=(44) +238 150000 +fi=(32) +611 75000 +fi=(44) +238 150000 +fe=(74) +479 525000 +0 25000 +479 50000 +fi=(28) +2415 25000 +fe=(74) +492 275000 ++16 50000 +915 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(74) +925 50000 +cfn=(5892) +calls=74000 137 +* 22178803 +fi=(27) +2177 100000 +0 400000 +2177 100000 +fe=(74) +925 400000 ++1 100000 +0 50000 +929 400000 +fi=(98) +1082 100000 +-17 50000 +fe=(74) +0 50000 +fi=(14) +454 25000 +fi=(96) +1039 100000 +cfi=(55) +cfn=(5736) +calls=37000 1337 +* 6550000 +fe=(74) +-76 75000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +969 100000 ++1 250000 +cfn=(5990) +calls=37000 67 +* 1474250 +* 25000 +fi=(98) +0 100000 +fi=(44) +245 200000 +fi=(18) +847 100000 +fe=(74) ++82 250000 +0 450000 +481 100000 +fi=(33) +3082 250000 +fe=(74) +0 75000 +fi=(14) +454 75000 +fi=(13) +4049 75000 +fi=(59) +2868 75000 +fi=(33) +1865 25000 +fi=(76) +282 50000 +fe=(74) +0 25000 +fi=(32) +611 25000 +fi=(76) +282 50000 +fe=(74) +516 75000 +cfn=(5618) +calls=37000 220 +* 1050000 +fi=(27) +2177 25000 +0 25000 +2177 50000 +fe=(74) +521 50000 +cfn=(5762) ::new +calls=37000 30 +* 6950000 +0 25000 +522 125000 +cfn=(5636) +calls=37000 997 +* 28271500 +fi=(27) +2177 50000 +fe=(74) +523 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 0 +* 2225000 +fi=(33) +996 75000 +cfn=(5814) +calls=37000 +31 +* 2700000 +* 25000 +fi=(59) +0 125000 +fe=(74) +988 400000 +fi=(18) +847 600000 +0 200000 +847 1200000 +fi=(32) +672 150 +cfn=(5530) +calls=37 -14 +* 2875 +fi=(33) +3101 25 +2981 25 +fe=(74) +988 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 850 +fi=(33) +4358 25 +fi=(18) +847 50 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 3250 +fi=(14) +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(74) +995 200 +fi=(18) +847 75 +0 25 +847 150 +fi=(33) +2877 25 +fi=(32) +611 50 +fi=(18) +1755 75 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37 0 +* 2225 +fe=(74) +977 75 +cfn=(5924) +calls=37 80 +* 29016 +* 25 + +fn=(5636) +997 200200 ++1 25025 +fi=(101) +0 25025 +fi=(100) +272 25025 +fe=(74) +999 500500 +fi=(99) +403 75075 +cfi=(94) +cfn=(5600) +calls=37037 601 +* 9309850 +* 75000 +cfi=(94) +cfn=(5600) +calls=37000 601 +* 1350000 +fi=(95) +855 150075 +fi=(41) +-90 50000 +fi=(95) ++90 100050 ++1 125000 +fe=(74) +999 25000 +fi=(103) +222 75000 +fi=(77) +21 75000 +fi=(76) +2635 25000 +fe=(74) +0 25000 +1004 50000 +cfi=(103) +cfn=(5718) +calls=37000 141 +* 950000 +0 50000 +fi=(14) +454 25000 +fi=(55) +1337 25000 +fi=(51) /rust/deps/hashbrown-0.17.1/src/map.rs +-53 25000 +0 25000 +1287 25000 +241 50000 +cfi=(52) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/mod.rs +cfn=(5740) ::hash_one::<&[u8]> +calls=37000 694 +* 4625000 +fi=(104) /rust/deps/hashbrown-0.17.1/src/control/tag.rs +47 75000 +fi=(55) +2452 150000 +0 25000 +fi=(18) +573 25000 +fi=(57) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/sse2.rs +1569 75000 +fi=(105) /rust/deps/hashbrown-0.17.1/src/control/bitmask.rs +40 50000 +-40 200000 +fi=(58) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/nonzero.rs +628 25000 +fi=(55) +2032 50000 +fi=(20) +1054 75000 +fi=(77) +21 50000 +fi=(106) /rust/deps/hashbrown-0.17.1/src/lib.rs +157 100000 +cob=(2) +cfi=(2) +cfn=(5752) +calls=37000 0 +* 493000 +* 25000 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +455 25000 +fe=(74) +1005 25000 +fi=(33) +1865 25000 +fi=(44) +238 50000 +fi=(32) +611 25000 +fi=(44) +238 50000 +fe=(74) +1007 100000 +fi=(101) +350 50000 +fe=(74) +1008 50000 +cfi=(107) +cfn=(5778) +calls=37000 236 +* 2078000 +fi=(27) +2177 25000 +0 100000 +2177 50000 +fe=(74) +0 75000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(74) +1009 75000 +cfi=(108) +cfn=(5790) +calls=37000 28 +* 2767000 +fi=(27) +2177 50000 +0 200000 +2177 75000 +fe=(74) +1009 225000 +fi=(98) ++73 75000 +-17 25000 +fi=(44) +245 50000 +0 25000 +fi=(98) +1082 25000 +-17 25000 +fi=(44) +245 50000 +fi=(18) +847 50000 +fe=(74) +1014 225000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 50000 +fi=(11) +0 25025 +fe=(74) +1024 25025 +cfi=(18) +cfn=(5612) +calls=37037 847 +* 1400450 +* 25025 +fi=(14) +454 25025 +fe=(74) +1025 50050 ++3 25025 +fi=(18) +847 50050 +fe=(74) +1029 225225 + +fn=(5712) +156 525000 +fi=(101) +0 75000 +fi=(100) +272 75000 +fe=(74) +157 1125000 +0 75000 +fi=(99) +403 225000 +cfi=(94) +cfn=(5600) +calls=111000 601 +* 12008500 +* 75000 +cfi=(94) +cfn=(5600) +calls=37000 601 +* 1350000 +fi=(95) +855 300000 +fi=(41) +-90 50000 +fi=(95) ++90 200000 ++1 100000 +fe=(74) +157 25000 +fi=(103) ++65 50000 +fi=(77) +21 50000 +fi=(76) +2635 25000 +fe=(74) +162 50000 +cfi=(103) +cfn=(5718) +calls=37000 -21 +* 950000 +fi=(77) +21 100000 +fi=(18) +847 50000 +fi=(23) +0 150000 +fe=(74) +168 75000 +cfi=(18) +cfn=(5612) +calls=111000 847 +* 2300000 ++2 675000 + +fn=(5466) ::deserialize_with_limit +365 250 +fi=(75) +810 300 +fi=(33) +462 150 +0 50 +fi=(85) +412 100 +cfi=(75) +cfn=(5468) +calls=37 1006 +* 24750 +fe=(74) +-38 225 +fi=(14) ++80 25 +fi=(59) +2454 100 +fe=(74) +376 50 +cfn=(5578) +calls=37 -33 +* 475 +fi=(27) +2177 50 +fe=(74) +379 50 +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/mod.rs +105 75 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/thread_local/native/lazy.rs +-46 50 +fi=(60) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cell.rs +558 50 +fi=(10) +2652 25 +fi=(11) +976 25 +fi=(59) +440 200 +fi=(23) +128 25 +cfi=(6) +cfn=(5090) +calls=37 0 +* 25 ++2 75 +cfi=(24) +cfn=(5092) +calls=37 -89 +* 1050 +fi=(28) +251 50 +0 25 +293 200 +fi=(59) ++27 75 +fe=(74) ++57 125 +cfn=(5588) +calls=37 +33 +* 284098132 +fi=(13) +4049 25 +fi=(59) +2868 25 +0 50 +2911 25 +cfn=(6140) +calls=37 2138 +* 1725 +0 25 +fe=(74) +401 75 +fi=(18) +847 75 +0 25 +847 150 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 850 +fi=(32) +425 50 +631 25 +425 25 +fi=(10) +1401 25 +fi=(23) +175 50 +cfi=(26) +cfn=(5682) +calls=37 65 +* 3850 +fe=(74) +408 275 + +fn=(5924) +80 225225 +fi=(14) +454 50050 +fi=(59) +2454 25025 +fi=(32) +611 25025 +fi=(33) +1865 75075 +fe=(74) +81 25025 +cfi=(45) /home/bailey/github/PolyXML/crates/polyxml-core/src/schema.rs +cfn=(5926) polyxml::schema::validate_content +calls=37037 725 +* 550550 +fi=(27) +2177 50050 +fi=(18) +0 50050 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 25025 +0 125125 +180 100100 +fi=(41) +634 25000 +fe=(74) +83 25000 +fi=(50) +-83 75025 +fi=(14) +1663 150050 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +fi=(45) +4 75025 +fe=(74) ++79 75025 +fi=(98) +1082 75000 +-30 25000 +fi=(44) +238 50000 +0 25000 +fi=(98) +1082 25000 +-30 25000 ++30 75075 +-30 25025 +-15 50050 +fe=(74) +96 25025 +-96 50 +fi=(98) +1082 25 +fe=(74) +97 300 +fi=(98) +996 50 ++56 25 +-56 25 +fe=(74) +97 25 +fi=(118) +-73 125 +fe=(74) ++73 25 +fi=(98) +2493 50 +0 125 +fe=(74) +99 200 +fi=(98) +2493 50 +0 25 +2493 50 ++5 50 +1082 50 +-30 25 +fi=(54) +871 25 +fi=(18) +1755 25 +fi=(41) +2869 50 +fi=(118) +80 25 +fi=(41) +2870 50 +fi=(118) +81 25 ++1 50 +fe=(74) ++16 100 ++1 50 +fi=(98) +1082 75 +-17 25 +fi=(44) +245 50 +0 25 +fi=(98) +1082 25 +-17 25 +fi=(44) +245 50 +fi=(18) +847 50 +0 25 +847 25 +cfi=(98) +cfn=(6132) +calls=37 2483 +* 500 +0 75 +847 25 +cfi=(98) +cfn=(5984) +calls=37 2373 +* 550 +0 25 +fi=(14) +454 25 +fe=(74) +104 100 +0 50000 +fi=(14) +454 25000 +fe=(74) +104 75000 +fi=(14) +454 25025 +fi=(33) +1865 25025 +fi=(14) +1663 50050 +0 100100 +fi=(98) +1052 125125 +fi=(14) +1663 150050 +fi=(118) +82 75025 +fi=(14) +1663 75025 +fi=(50) +180 75025 +0 75025 +fi=(98) +1082 225075 +-30 75025 +fi=(44) +238 150050 +0 75025 +fi=(98) +1082 75025 +-30 75025 +fi=(41) +743 150050 +fi=(45) +-74 150050 +fi=(111) +0 25025 +fe=(74) +131 100100 ++1 75075 +fi=(98) +1082 25025 +1607 25025 +fe=(74) +132 25025 +fi=(98) +1615 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 0 +* 1926925 +2552 50050 +-1 150150 +fi=(33) +3996 25025 +cfi=(117) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter.rs +cfn=(5946) > as alloc::vec::spec_from_iter::SpecFromIter, smallvec::IntoIter<[core::option::Option; 8]>>>::from_iter +calls=37037 32 +* 11517075 +0 25025 +fe=(74) +132 25025 +cfi=(33) +cfn=(5964) +calls=37037 1723 +* 7835597 +-2 125125 ++4 50050 +0 25000 +fi=(18) +847 25000 +cfi=(98) +cfn=(5984) +calls=37000 2373 +* 550000 +* 175175 +fi=(32) +425 50050 +631 25025 +fe=(74) +134 225225 + +fn=(5464) polyxml::deserialize +362 50 +cfn=(5466) +calls=37 +3 +* 284135282 + +fn=(5762) +30 150000 +fi=(41) +634 25000 +fi=(33) +3101 25000 +fe=(74) +38 25000 ++1 100000 +cfi=(98) +cfn=(5632) +calls=37000 2052 +* 4175000 +-7 25000 ++9 75000 +-4 125000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37000 -37 +* 1925000 +* 150000 ++8 150000 + +fl=(114) +fn=(5918) +45 75000 +-45 25000 +46 50000 +-46 50000 +46 100000 ++36 50000 +fi=(115) ++70 50000 +fe=(114) +-67 50000 ++22 25000 +fi=(116) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-parse-float-1.0.6/src/table_decimal.rs +-30 75000 +fi=(145) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/arith.rs +515 50000 +fe=(114) +100 75000 + +fl=(101) +fn=(5696) +0 75000 +fi=(100) +202 75000 +fi=(92) +380 150000 +fi=(100) +202 75000 +fi=(92) +384 150000 +fi=(43) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/mod.rs +1229 25000 +fi=(91) +424 75000 +fi=(100) +203 150000 +fe=(101) + +fl=(18) +fn=(5612) +847 700200 +fi=(32) +425 350100 +631 175050 +425 75000 +fi=(10) +1401 75000 +fi=(23) +175 150000 +cfi=(26) +cfn=(5682) +calls=111000 65 +* 2550000 +fe=(18) +847 1925550 + +fn=(6382) core::ptr::drop_glue:: +847 275 +fi=(14) +454 25 +fi=(13) +4049 25 +fi=(59) +2868 25 +fe=(18) +847 450 +cfn=(6383) core::ptr::drop_glue::'2 +calls=37 * +* 12447414 +* 200 +cob=(2) +cfi=(2) +cfn=(4868) +calls=37 0 +* 825 + +fn=(6383) +847 275 +fi=(32) +611 25 +fi=(33) +4358 25 +fe=(18) +847 125 +0 25 +847 50 +cfn=(6383) +calls=37 * +* 8314 +* 49950 +cfn=(6383) +calls=36963 * +* 12284032 +* 100000 +fi=(32) +631 50 +fe=(18) +847 175 +cob=(2) +cfi=(2) +cfn=(4868) +calls=37 0 +* 4368 +* 1700000 +fi=(32) +631 50000 +425 25000 +fi=(23) +312 25000 +fi=(14) +454 25000 +fi=(13) +4049 25000 +fi=(59) +2868 25000 +fe=(18) +847 900000 +cfn=(6383) +calls=111000 * +* 6176136 +* 525000 +cob=(2) +cfi=(2) +cfn=(4868) +calls=74000 0 +* 8992346 + +fl=(87) +fn=(5514) +57 1500500 +fi=(54) +473 450150 +fi=(13) +3994 300100 +fi=(78) +153 900300 +cfi=(84) +cfn=(5520) memchr::arch::x86_64::memchr::memchr3_raw::find_avx2 +calls=222073 1042 +* 4203450 +fi=(41) +2869 300100 +fi=(88) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/arch/generic/memchr.rs +0 150050 +fi=(54) +623 300100 +fe=(87) +59 300100 +fi=(54) +871 150050 +fe=(87) +59 625200 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5520) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fi=(88) +0 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 375100 +-59 150050 +59 600200 +-59 150050 +59 200050 ++14 1350450 +fi=(88) +-73 25000 +fi=(54) +623 50000 +fe=(87) +59 50000 +fi=(54) +871 25000 +fe=(87) +59 75000 +fi=(13) +3994 25000 +fi=(78) +153 125000 +cfi=(84) +cfn=(5520) +calls=37000 1042 +* 700000 +fi=(41) +2869 50000 +fe=(87) + +fl=(90) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/reader/state.rs +fn=(5864) ::emit_end +197 525175 +fi=(91) +-68 150050 +fi=(43) +1229 75025 +fi=(91) +145 75025 +fi=(43) +1229 75025 +fi=(91) +262 75025 +0 300100 +fe=(90) +214 225075 +fi=(93) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/utils.rs +315 300100 +0 75025 +fi=(50) +402 150050 +fi=(93) +-87 75025 +fi=(33) +2873 225075 ++4 150050 +fi=(32) +611 75025 +fi=(18) +1755 75025 +fe=(90) +228 150050 +fi=(32) +611 75025 +fi=(33) +1865 75025 +fi=(92) +380 150050 ++4 150000 +fi=(43) +1229 75000 +fi=(91) +493 75000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1490 150050 +fi=(92) +380 450150 +fi=(32) +611 75000 +fi=(43) +1229 75000 +fi=(40) +1491 75000 +fi=(33) +1828 75025 +fe=(90) +257 375125 ++1 675225 +fi=(92) +384 225075 +fi=(91) +221 150050 +fi=(54) +871 75025 +fi=(77) +21 150050 +-21 75025 +157 600200 +cob=(2) +cfi=(2) +cfn=(5752) +calls=111037 0 +* 1617539 +* 450150 +fe=(90) ++73 75025 +fi=(92) +394 75025 +fi=(91) ++30 75025 +fe=(90) + +fn=(5552) ::emit_start +314 750250 +fi=(92) ++70 150050 +fi=(43) +1229 75025 +fi=(91) +493 75025 +0 75025 +221 150050 +fi=(76) +2736 150050 +fi=(77) +157 75025 +fi=(76) +2738 75025 +0 75025 +2738 75025 +fe=(90) +345 150050 +fi=(10) +1092 75025 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 75025 +fi=(91) +424 75025 +0 225075 +fi=(93) +331 325175 +-4 650350 ++1 700350 +-13 350175 +0 50000 +fi=(33) +3101 25000 +1029 25000 ++3 50000 +fi=(32) +611 75025 +fi=(18) +1963 75025 +fi=(33) +1038 150050 +fi=(92) +380 150050 ++4 150050 +fi=(43) +1229 25000 +fi=(91) +424 25000 +fi=(33) +1033 100 +cfi=(32) +cfn=(5568) >::grow_one +calls=37 186 +* 2675 +* 75 +0 50025 +3101 50025 +1029 50025 ++3 100075 +fi=(91) +424 50025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +0 75025 +fi=(20) +970 75025 +fi=(18) +573 300100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=111037 0 +* 1125375 +* 75025 +fi=(33) +2986 225075 +fe=(90) +0 450150 +356 675225 +fi=(32) +672 250 +cfn=(5530) +calls=74 -14 +* 5825 +* 50 +fi=(33) +3101 100 +fe=(90) + +fn=(5828) ::emit_text +63 50000 ++1 100000 ++11 200000 ++1 150000 + +fl=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +fn=(5128) std::sys::backtrace::__rust_begin_short_backtrace:: +fi=(146) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfi=(24) +cfn=(5130) xml_diagnostics::main +calls=1 43 +250 296585254 +fe=(30) + +fl=(117) +fn=(5946) +32 200200 +fi=(98) +2493 100100 +0 25025 +2498 50050 +1082 25025 +-30 25025 +fi=(37) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/spec_from_iter_nested.rs +0 25025 +26 225225 +fi=(98) +2506 25025 +fi=(10) +-10 75075 +fi=(19) +1051 75075 +fi=(10) +3212 25025 +fi=(37) +0 25025 +fi=(47) +478 75075 +fi=(98) +1052 25025 +fi=(54) +871 25025 +fi=(18) +1755 25025 +fi=(37) +24 50050 +fe=(117) ++10 200200 +fi=(32) +461 50050 +0 25025 +cfi=(6) +cfn=(5090) +calls=37037 0 +0 25025 +0 25025 +fi=(23) +130 75075 +cfi=(24) +cfn=(5092) +calls=37037 -89 +* 4837200 +fi=(32) +470 50050 +0 50050 +fi=(18) +1963 200200 +fi=(37) +36 100100 ++5 100100 +cob=(2) +cfi=(2) +cfn=(4488) +calls=37037 -41 +* 1926925 +fi=(98) +2493 125125 +0 50 +2493 50 +0 100000 +fi=(33) +4100 225000 +fi=(18) +1963 400000 +fi=(33) +4111 50000 +2224 50000 +fi=(98) +2493 150000 ++5 100000 +fi=(18) +1755 50000 +fi=(33) +4100 550000 ++2 100000 +fi=(98) +0 75000 +2493 50000 +0 25025 +fi=(18) +847 25025 +cfi=(98) +cfn=(5958) +calls=37037 2373 +* 525525 +fi=(37) +42 150150 +fe=(117) + +fl=(84) +fn=(5490) +659 350100 +fi=(78) +0 700200 +fi=(54) +623 350100 +fe=(84) ++40 350100 ++1 50100 +fi=(88) +1161 50050 +0 25025 +1162 25025 +fe=(84) +668 50050 +fi=(88) +1162 47250 +fe=(84) +668 239000 +fi=(54) +389 72250 +fi=(88) +1161 144500 +0 25000 +fi=(78) +86 75000 +fi=(18) +573 150000 +fi=(147) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/../../stdarch/crates/core_arch/src/x86/avx2.rs +699 300000 +2315 150000 +2163 150000 +fi=(148) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.8.3/src/vector.rs +147 150000 +fi=(88) +679 150000 +fi=(18) +573 25 +fi=(57) +920 50 +-25 25 +1569 25 +fi=(148) +147 25 +fi=(88) +679 25 +fe=(84) +0 450075 +fi=(78) +86 300100 +fe=(84) + +fn=(5520) +1042 400100 +0 1400350 +fi=(54) +623 400100 +fe=(84) +1046 400100 ++1 150 +fi=(88) +1161 50 +0 25 +1162 50 +fe=(84) +1051 25 +fi=(88) +1162 400 +fe=(84) +1051 1050 +fi=(54) +389 200 +fi=(88) +1161 400 +fi=(18) +573 199975 +fi=(147) +699 399950 +2315 199975 +699 199975 +2315 199975 +2163 199975 +fi=(148) +147 199975 +fi=(88) +972 199975 +fi=(18) +573 50 +fi=(57) +920 100 +-25 50 ++25 50 +-25 50 +1569 50 +fi=(148) +147 50 +fi=(88) +972 50 +fe=(84) +0 800100 +fi=(78) +86 400050 +-86 25 +86 50 +fe=(84) + +fl=(8) +fn=(4178) +fi=(146) +cfn=(5126) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 296585254 +fe=(8) + +fn=(5126) +cfi=(30) +cfn=(5128) +calls=1 162 +206 296585254 + +fl=(75) +fn=(5468) +1006 2400600 +289 1400350 +fi=(76) +2635 50 +fi=(77) +157 125 +fi=(85) +24 25 +fe=(75) +306 25 ++45 300100 +fi=(33) +3101 150050 +fi=(76) +137 300100 +0 300100 +fi=(54) +871 150050 +fi=(13) +3994 300100 +fi=(78) +153 750250 +cfi=(84) +cfn=(5490) +calls=222073 659 +* 3301100 +fi=(41) +2869 300100 +fi=(85) +72 600200 ++7 100000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 100000 +-94 50000 +fi=(20) +970 50000 +fi=(18) +573 200000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=74000 0 +* 705000 +* 100000 +fi=(33) +2986 100000 +fi=(85) +0 50000 +fi=(44) +549 100000 +fi=(142) +389 100000 +fi=(44) +544 50000 +fi=(85) +79 100000 +fi=(44) +544 150000 +90 100000 +fi=(85) +-4 150000 +cfi=(38) +cfn=(5180) +calls=74000 +3 +* 3700250 +* 100000 +-25 150000 ++14 100050 +fi=(142) +389 100050 +fe=(75) +-34 100050 +0 300150 +437 100050 +fi=(44) +544 200100 +fe=(75) +437 50000 +fi=(44) +544 100000 +fe=(75) +0 150050 +fi=(142) +389 300100 +fi=(44) +90 150050 +fi=(76) ++66 300100 +fi=(142) +389 300100 +fi=(76) +156 150050 +fi=(72) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/clone.rs +716 300100 +fe=(75) +440 600200 +0 75025 +464 225075 +cfi=(85) +cfn=(5502) +calls=111037 211 +* 19183725 +-1 150050 ++4 375125 +cfi=(90) +cfn=(5864) +calls=111037 197 +* 8894789 +* 75025 +0 75025 +488 225075 +cfi=(85) +cfn=(5502) +calls=111037 211 +* 22204750 +-1 150050 +0 250000 +cfi=(90) +cfn=(5828) +calls=74000 63 +0 500000 +fi=(27) +2177 50000 +0 200000 +2177 100000 +fe=(75) +0 300000 +323 50000 +491 375125 +cfi=(90) +cfn=(5552) +calls=111037 314 +* 9137500 +* 75025 +-91 750250 +1011 1800450 + +fl=(55) +fn=(5736) +1337 100000 +fi=(51) +-53 100000 +0 900000 +1287 200000 +241 200000 +cfi=(52) +cfn=(5740) +calls=148000 694 +* 18150000 +fi=(104) +47 300000 +fe=(55) +2452 800000 +0 100000 +fi=(18) +573 100000 +fi=(57) +1569 300000 +fi=(105) +40 200000 +-40 500000 +fi=(58) +628 100000 +fe=(55) +2032 200000 +fi=(20) +1054 300000 +fi=(77) +21 200000 +fi=(106) +157 400000 +cob=(2) +cfi=(2) +cfn=(5752) +calls=148000 0 +* 1948000 +* 100000 +fi=(47) +455 100000 +fe=(55) +1217 1000000 +fi=(51) ++76 100000 +fe=(55) + +fn=(6142) +3486 175 +2656 50 +2271 25 +3498 200 + +fl=(32) +fn=(5568) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5228) ::finish_grow +calls=37 +15 +* 2075 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fn=(5228) +544 2600 +fi=(10) +3212 2600 +fi=(47) +478 975 +0 325 +fe=(32) +631 325 +fi=(10) +1401 300 +fi=(23) +228 1500 +cfi=(24) +cfn=(5538) +calls=1451 41 +* 54143 +fi=(27) +965 600 +fi=(23) +298 50 ++4 25 +cfi=(6) +cfn=(5090) +calls=39 0 +* 25 +130 75 +cfi=(24) +cfn=(5092) +calls=39 -89 +* 950 +fi=(27) +965 50 ++1 975 +fe=(32) +0 650 +564 1950 +-20 600600 +fi=(10) +3212 600600 +fi=(47) +478 225225 +fe=(32) +631 150150 +fi=(10) +1401 25 +fi=(23) +228 125 +cfi=(24) +cfn=(5538) +calls=1037 41 +* 1400 +fi=(27) +965 50 +fi=(23) +298 150100 ++4 75050 +cfi=(6) +cfn=(5090) +calls=111074 0 +* 75050 +130 225150 +cfi=(24) +cfn=(5092) +calls=111074 -89 +* 3152000 +fi=(27) +965 150100 ++1 225225 +fe=(32) +0 150150 +564 450450 +-20 400 +fi=(86) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/layout.rs +75 50 ++38 50 +0 50 +fe=(32) +631 100 +fi=(23) +298 100 +128 50 +cfi=(6) +cfn=(5090) +calls=74 0 +* 50 ++2 150 +cfi=(24) +cfn=(5092) +calls=74 -89 +* 1900 +fi=(27) +965 100 ++1 150 +fe=(32) +0 100 +564 300 + +fn=(5898) +447 225000 +fi=(10) +3212 175000 +fi=(47) +478 50000 +fe=(32) +-17 50000 +0 50000 +cfi=(6) +cfn=(5090) +calls=37000 0 +0 25000 +0 50000 +465 50000 ++13 75000 +0 50000 +483 175000 +fi=(23) +130 25000 +cfi=(24) +cfn=(5092) +calls=37000 -89 +* 10653953 +fe=(32) +470 50000 + +fn=(5660) >>::grow_one +186 300000 +493 75000 ++30 75000 +fi=(19) +1051 225000 +fe=(32) +529 450000 +cfn=(5228) +calls=111000 +15 +* 6225000 +fi=(27) +2177 150000 ++1 75000 +fe=(32) +773 75000 ++1 75000 +189 300000 + +fn=(6010) +186 900 +493 225 ++30 225 +fi=(19) +1051 675 +fe=(32) +529 1350 +cfn=(5228) +calls=333 +15 +* 40950 +fi=(27) +2177 450 ++1 225 +fe=(32) +773 225 ++1 225 +189 900 + +fn=(5506) +186 300 +493 50 ++30 50 +fi=(19) +1051 150 +fe=(32) +529 200 +cfn=(5228) +calls=74 +15 +* 3550 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +189 250 + +fn=(5530) +658 300 +512 150 +fi=(10) +938 75 +fi=(47) +478 75 +0 75 +fe=(32) +523 150 +fi=(19) +1051 150 +fe=(32) +159 525 +fi=(19) +1051 225 +fe=(32) +529 300 +cfn=(5228) +calls=1118 +15 +* 6775 +fi=(27) +2177 150 ++1 75 +fe=(32) +773 75 ++1 75 +668 300 +-10 150 +fi=(10) +938 50 +fi=(47) +478 50 +0 50 +fe=(32) +523 100 +fi=(19) +1051 250 +fe=(32) +529 350 +cfn=(5228) +calls=1074 +15 +* 4375 +fi=(27) +2177 100 ++1 50 +fe=(32) +773 50 ++1 50 +668 200 + +fn=(5684) +186 100 +493 25 ++30 25 +fi=(19) +1051 75 +fe=(32) +529 150 +cfn=(5228) +calls=37 +15 +* 20393 +fi=(27) +2177 50 ++1 25 +fe=(32) +773 25 ++1 25 +189 100 + +fl=(94) +fn=(5656) ::check_for_duplicates +1036 525000 ++5 150000 +0 150000 +fi=(33) +3101 75000 +fe=(94) +1042 150000 +0 300000 +fi=(32) +611 150000 +fi=(20) +970 300000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +fe=(94) +0 225000 +fi=(33) +1032 150000 ++1 75000 +cfi=(32) +cfn=(5660) +calls=111000 186 +* 8025000 +fi=(32) +611 150000 +0 225000 +fi=(18) +1963 225000 +fi=(33) +1038 225000 +fe=(94) ++16 225000 ++1 600000 + +fn=(5600) +601 1500300 ++1 1000200 +cfn=(5602) ::next +calls=370074 1123 +* 28202100 +* 1250250 ++1 350100 ++1 450000 +fi=(91) +129 525000 +fe=(94) +777 225000 +fi=(91) +129 150000 ++4 150000 ++12 150000 +fi=(43) +1229 150000 +fi=(91) +146 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +129 375000 ++4 150000 ++12 150000 +fi=(43) +1229 75000 +fi=(91) +145 75000 ++1 150000 +fi=(43) +1229 75000 +fi=(91) +262 75000 +fi=(54) +871 225000 +fe=(94) +604 375000 ++3 1250250 + +fn=(5602) +1123 1750350 ++1 750150 +955 750150 ++2 250050 +1124 250050 +fi=(44) +544 500100 +fi=(14) +1663 500100 +fi=(50) +180 250050 +fe=(94) +1125 75000 +fi=(44) +90 375000 +-90 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +fe=(94) +1130 75000 +fi=(14) +627 75000 +fe=(94) +1130 75000 +fi=(93) +315 75000 +0 225000 +fi=(50) +180 75000 +fe=(94) +0 75000 +fi=(50) +180 75000 +fe=(94) +1138 175050 ++1 175050 +0 75000 +fi=(50) +180 75000 +fe=(94) +1143 300000 +fi=(14) +1663 150000 +fi=(50) +180 75000 +fe=(94) +1143 450000 +0 375000 +1188 525000 +0 175050 +1261 2250450 +-73 450000 +cfn=(5656) +calls=111000 1036 +* 12075000 +* 150000 +fi=(14) +1663 300000 +fi=(50) +180 75000 +0 225000 +fe=(94) +1199 150000 +fi=(93) +315 75000 +0 150000 +fe=(94) +0 225000 +fi=(14) +1663 150000 +fi=(50) +180 300000 +fe=(94) +1243 75000 +fi=(149) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs +2490 75000 +fe=(94) +1243 216750 +fi=(149) +2490 216750 +fi=(14) +627 216750 +1663 433500 +fi=(50) +180 216750 +fi=(93) +0 150000 +fe=(94) +1243 75000 +0 150000 +1243 150000 +1113 150000 +0 375000 + +fl=(26) +fn=(5682) +65 75200 +cob=(2) +cfi=(2) +cfn=(4868) +calls=112323 -65 +* 2487000 + +fl=(45) +fn=(5926) +725 200200 ++1 100100 +0 25025 +735 225225 + +fl=(53) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hash/sip.rs +fn=(5290) as core::hash::Hasher>::write +256 250000 ++2 250000 ++4 750000 +0 500000 +278 250000 ++1 750000 ++3 500000 +0 625000 +fi=(18) +573 125000 +fe=(53) +288 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fe=(53) +78 125000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fe=(53) +79 125000 +fi=(47) +2215 250000 +fe=(53) +78 125000 +290 125000 ++2 125000 +-10 250000 +0 500000 +126 500000 +fi=(18) +573 200000 +fe=(53) +132 400000 +0 300000 +132 450000 +fi=(54) +871 25000 +fi=(18) +573 25000 +fe=(53) +134 75000 ++1 25000 ++2 500000 ++2 150000 +298 25000 +0 25000 +300 50000 +-2 225000 +0 225000 +300 450000 + +fl=(78) +fn=(5840) +78 50000 +fi=(84) +184 100000 +0 150000 +fi=(54) +623 100000 +fi=(84) +188 100000 ++1 100000 +fi=(88) +1161 50000 +0 50000 +fi=(84) +193 1050150 +fi=(54) +389 350050 +fi=(88) +1161 700100 +0 100000 +fe=(78) +86 100000 + +fl=(24) +fn=(5092) +41 125250 +fi=(13) +3994 125250 +762 125250 +fe=(24) +16 125250 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 501000 +fi=(26) +30 250500 ++1 250500 +cob=(2) +cfi=(2) +cfn=(4226) +calls=186395 -31 +* 17149778 +fe=(24) + +fn=(6436) measured_region +79 9 +fi=(19) +2144 1 +fi=(34) +1100 1 +0 10 +fi=(26) +0 5 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 4 +fi=(13) +4029 1 +fi=(59) +2434 1 +fi=(26) +0 24 +fi=(150) +491 96 +fi=(13) +4029 24 +fi=(59) +2434 24 +fe=(24) +89 125 +cfi=(74) +cfn=(5464) +calls=25 362 +* 284135332 +fi=(27) +1230 50 ++1 200 +fe=(24) +89 50 +cfi=(18) +cfn=(6382) +calls=25 847 +* 12449239 +fi=(19) +2144 25 +fi=(34) +1100 25 +fe=(24) +94 8 + +fn=(5538) +41 25350 +fi=(13) +3994 25350 +762 25350 +fe=(24) +33 25350 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 126750 +405 50700 +fi=(26) +70 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4458) +calls=37037 -71 +* 6884647 +-1 650 ++1 650 +cob=(2) +cfi=(2) +cfn=(4458) +calls=2488 -71 +* 50668 +fe=(24) + +fn=(5130) +cfn=(6436) +calls=1 79 +70 296585254 + +fl=(52) +fn=(5740) +694 750000 ++5 125000 +fi=(53) +203 250000 +fi=(48) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/hash/random.rs +84 125000 +fi=(53) +204 250000 +fi=(48) +84 625000 +fi=(10) +4058 375000 +fi=(53) +233 375000 +cfn=(5290) +calls=185000 +23 +* 6875000 +* 500000 +cfn=(5290) +calls=185000 +23 +* 3650000 ++81 375000 +-2 250000 ++4 250000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(47) +2215 250000 +fi=(53) +78 125000 +318 125000 ++2 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 250000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 125000 +fi=(10) +2652 125000 +fi=(53) +79 125000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(10) +2652 250000 +fi=(47) +2215 125000 +fi=(53) +78 125000 +fi=(47) +2215 125000 +fi=(53) +79 125000 +fi=(10) +2652 125000 +fi=(47) +2215 500000 +fi=(53) +323 375000 +fe=(52) +702 625000 + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4126) +calls=1 0 +0 296585254 + +totals: 296585254 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-Cargo.toml b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-Cargo.toml new file mode 100644 index 0000000..7afbad6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-Cargo.toml @@ -0,0 +1,9 @@ +[package] +name="xml-diagnostics" +version="0.0.0" +edition="2021" +[workspace] +[dependencies] +polyxml={path="/home/bailey/github/PolyXML/crates/polyxml-core"} +[profile.release] +debug=1 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-allocations.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-allocations.txt new file mode 100644 index 0000000..da27eb0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-allocations.txt @@ -0,0 +1,12 @@ +memcap: <=7843 MiB (60% of 13072 MiB available) [systemd MemoryMax, swap off] +operation=read,count=0,iterations=1,allocations=12,reallocations=5,requested_bytes=11093,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7857 MiB (60% of 13095 MiB available) [systemd MemoryMax, swap off] +operation=write,count=0,iterations=1,allocations=2,reallocations=2,requested_bytes=554,input_bytes=94,output_bytes=94,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7857 MiB (60% of 13095 MiB available) [systemd MemoryMax, swap off] +operation=read,count=1000,iterations=1,allocations=5010,reallocations=1014,requested_bytes=717402,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7856 MiB (60% of 13094 MiB available) [systemd MemoryMax, swap off] +operation=write,count=1000,iterations=1,allocations=1001,reallocations=2007,requested_bytes=158560,input_bytes=63911,output_bytes=63411,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7856 MiB (60% of 13094 MiB available) [systemd MemoryMax, swap off] +operation=read,count=10000,iterations=1,allocations=50010,reallocations=10019,requested_bytes=7774738,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 +memcap: <=7855 MiB (60% of 13092 MiB available) [systemd MemoryMax, swap off] +operation=write,count=10000,iterations=1,allocations=10001,reallocations=20011,requested_bytes=2376640,input_bytes=668911,output_bytes=663911,field_schema_bytes=160,scalar_type_bytes=32,value_type_bytes=32,poly_value_bytes=56 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-build.txt new file mode 100644 index 0000000..cf7b201 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-build.txt @@ -0,0 +1,37 @@ +memcap: <=7857 MiB (60% of 13095 MiB available) [systemd MemoryMax, swap off] + Compiling proc-macro2 v1.0.107 + Compiling quote v1.0.47 + Compiling unicode-ident v1.0.26 + Compiling syn v3.0.6 + Compiling serde_core v1.0.229 + Compiling memchr v2.8.3 + Compiling lexical-util v1.0.7 + Compiling serde v1.0.229 + Compiling serde_derive v1.0.229 + Compiling siphasher v1.0.4 + Compiling zmij v1.0.23 + Compiling phf_shared v0.14.0 + Compiling lexical-parse-integer v1.0.6 + Compiling lexical-write-integer v1.0.6 + Compiling aho-corasick v1.1.5 + Compiling thiserror v2.0.21 + Compiling regex-syntax v0.8.11 + Compiling serde_json v1.0.151 + Compiling fastrand v2.5.0 + Compiling phf_generator v0.14.0 + Compiling regex-automata v0.4.18 + Compiling lexical-write-float v1.0.6 + Compiling lexical-parse-float v1.0.6 + Compiling thiserror-impl v2.0.21 + Compiling memo-map v0.3.4 + Compiling itoa v1.0.18 + Compiling minijinja v2.24.0 + Compiling lexical-core v1.0.6 + Compiling regex v1.13.1 + Compiling phf_codegen v0.14.0 + Compiling quick-xml v0.42.0 + Compiling heck v0.5.0 + Compiling smallvec v1.16.2 + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling xml-diagnostics v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected) + Finished `release` profile [optimized + debuginfo] target(s) in 1m 11s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-fixtures.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-fixtures.rs new file mode 100644 index 0000000..f231439 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-fixtures.rs @@ -0,0 +1,85 @@ +use std::hint::black_box; + +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + (catalog_schema, xml.into_bytes()) +} + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-harness.rs new file mode 100644 index 0000000..1fbe95d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-harness.rs @@ -0,0 +1,94 @@ +// Fixture definitions are extracted verbatim from core_benchmarks.rs by run.py. +include!("fixtures.rs"); + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +struct CountingAllocator; +static COUNTING: AtomicBool = AtomicBool::new(false); +static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static REALLOCATIONS: AtomicUsize = AtomicUsize::new(0); +static BYTES: AtomicUsize = AtomicUsize::new(0); + +// Diagnostic instrumentation only. The benchmark consumers use System directly. +unsafe impl GlobalAlloc for CountingAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc(layout) } + } + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + ALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(layout.size(), Ordering::Relaxed); + } + unsafe { System.alloc_zeroed(layout) } + } + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + if COUNTING.load(Ordering::Relaxed) { + REALLOCATIONS.fetch_add(1, Ordering::Relaxed); + BYTES.fetch_add(new_size, Ordering::Relaxed); + } + unsafe { System.realloc(ptr, layout, new_size) } + } +} +#[global_allocator] +static ALLOCATOR: CountingAllocator = CountingAllocator; + +fn main() { + let args: Vec = std::env::args().collect(); + let operation = args.get(1).expect("read or write"); + let count: usize = args + .get(2) + .expect("0 for sensor, or catalog count") + .parse() + .unwrap(); + let iterations: usize = args.get(3).expect("iteration count").parse().unwrap(); + let mode = args.get(4).map(String::as_str).unwrap_or("allocations"); + let (schema, xml) = if count == 0 { + build_sensor_fixture() + } else { + build_catalog_fixture(count) + }; + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let root = if count == 0 { "Sensor" } else { "Catalog" }; + let output = serialize(root, &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + for _ in 0..10 { + if operation == "read" { + black_box(deserialize(&xml, Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize(root, &value, &schema, None).unwrap()); + } + } + COUNTING.store(mode == "allocations", Ordering::Relaxed); + measured_region(operation, iterations, &xml, &value, root, &schema); + COUNTING.store(false, Ordering::Relaxed); + println!("operation={operation},count={count},iterations={iterations},allocations={},reallocations={},requested_bytes={},input_bytes={},output_bytes={},field_schema_bytes={},scalar_type_bytes={},value_type_bytes={},poly_value_bytes={}", + ALLOCATIONS.load(Ordering::Relaxed), REALLOCATIONS.load(Ordering::Relaxed), BYTES.load(Ordering::Relaxed), xml.len(), output.len(), + std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::(), std::mem::size_of::()); +} + +#[inline(never)] +#[no_mangle] +fn measured_region( + operation: &str, + iterations: usize, + xml: &[u8], + value: &polyxml::PolyValue, + root: &str, + schema: &Arc, +) { + for _ in 0..iterations { + if operation == "read" { + black_box(deserialize(black_box(xml), Arc::clone(schema)).unwrap()); + } else { + black_box(serialize(root, black_box(value), schema, None).unwrap()); + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-metadata.json new file mode 100644 index 0000000..26a5e12 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected-metadata.json @@ -0,0 +1,8 @@ +{ + "revision": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d", + "core_status": "", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n", + "executable": "/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics", + "profile": "release debug=1; allocation instrumentation; not used for latency numbers" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected.lock new file mode 100644 index 0000000..1614ee2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/selected.lock @@ -0,0 +1,317 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-diagnostics" +version = "0.0.0" +dependencies = [ + "polyxml", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-annotated.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-annotated.txt new file mode 100644 index 0000000..00922d9 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-annotated.txt @@ -0,0 +1,92 @@ +-------------------------------------------------------------------------------- +Profile data file 'benchmarks/rust-runtime-investigation/target/evidence/selected-diagnostics/write-1000.callgrind' (creator: callgrind-3.26.0) +-------------------------------------------------------------------------------- +I1 cache: +D1 cache: +LL cache: +Timerange: Basic block 0 - 27961426 +Trigger: Program termination +Profiled target: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics write 1000 25 instructions (PID 394749, part 1) +Events recorded: Ir +Events shown: Ir +Event sort order: Ir +Thresholds: 95 +Include dirs: +User annotated: +Auto-annotation: off + +-------------------------------------------------------------------------------- +Ir +-------------------------------------------------------------------------------- +73,268,130 (100.0%) PROGRAM TOTALS + +-------------------------------------------------------------------------------- +Ir file:function +-------------------------------------------------------------------------------- +7,975,000 (10.88%) crates/polyxml-core/src/serializer.rs:::write_model::<&mut alloc::vec::Vec>'2 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +6,239,550 ( 8.52%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs:core::str::converts::from_utf8 +5,451,300 ( 7.44%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs:>>::write_event:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +4,801,200 ( 6.55%) ???:0x0000000000197a00 [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,962,775 ( 4.04%) ???:realloc [/usr/lib/x86_64-linux-gnu/libc.so.6] +2,500,200 ( 3.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +2,240,625 ( 3.06%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs:::format_scalar_to +2,100,350 ( 2.87%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs:core::str::converts::from_utf8 [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +2,100,000 ( 2.87%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:::write_model::<&mut alloc::vec::Vec>'2 +2,050,200 ( 2.80%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> +2,012,750 ( 2.75%) crates/polyxml-core/src/serializer.rs:::format_scalar_to [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +1,800,700 ( 2.46%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:>>::write_event:: +1,726,575 ( 2.36%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>>::write_event:: +1,433,475 ( 1.96%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs:::format_scalar_to +1,325,400 ( 1.81%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:>>::write_event:: +1,187,750 ( 1.62%) ???:0x00000000000b4180 [/usr/lib/x86_64-linux-gnu/libc.so.6] +1,175,000 ( 1.60%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::write_model::<&mut alloc::vec::Vec>'2 +1,150,000 ( 1.57%) crates/polyxml-core/src/serializer.rs:::validate_scalar [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +1,079,375 ( 1.47%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:>::reserve::do_reserve_and_handle:: [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] +1,062,650 ( 1.45%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 916,750 ( 1.25%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:quick_xml::escape::_escape::::{closure#0}, &str> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 877,975 ( 1.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::finish_grow [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 850,000 ( 1.16%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:::write_model::<&mut alloc::vec::Vec>'2 + 825,925 ( 1.13%) ???:free [/usr/lib/x86_64-linux-gnu/libc.so.6] + 775,225 ( 1.06%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:>>::write_event:: + 651,125 ( 0.89%) ???:malloc [/usr/lib/x86_64-linux-gnu/libc.so.6] + 600,150 ( 0.82%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs:>>::write_event:: + 500,000 ( 0.68%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attribute::<(&str, &str)> + 466,750 ( 0.64%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 451,575 ( 0.62%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::finish_grow + 450,450 ( 0.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:core::str::converts::from_utf8 + 450,000 ( 0.61%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attribute::<(&str, &str)> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 450,000 ( 0.61%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 425,425 ( 0.58%) crates/polyxml-core/src/schema.rs:::matches_variant [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 425,125 ( 0.58%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:>>::write_event:: + 425,000 ( 0.58%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::push_attr [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 402,925 ( 0.55%) crates/polyxml-core/src/serializer.rs:::write_model::<&mut alloc::vec::Vec> [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 400,000 ( 0.55%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::push_attr + 400,000 ( 0.55%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:::write_model::<&mut alloc::vec::Vec>'2 + 375,000 ( 0.51%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 351,225 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs:__rustc::__rust_realloc + 350,100 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs:>>::write_event:: + 350,000 ( 0.48%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs:::push_attr + 314,000 ( 0.43%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs:quick_xml::escape::_escape::::{closure#0}, &str> + 300,000 ( 0.41%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs:>::from [/home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics] + 300,000 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:::write_model::<&mut alloc::vec::Vec>'2 + 300,000 ( 0.41%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::write_model::<&mut alloc::vec::Vec>'2 + 280,300 ( 0.38%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs:::format_scalar_to + 262,500 ( 0.36%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs:::format_scalar_to + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::finish_grow + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:>::reserve::do_reserve_and_handle:: + 250,875 ( 0.34%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:::finish_grow + 225,225 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs:::matches_variant + 225,000 ( 0.31%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs:::push_attr + 224,825 ( 0.31%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs:::format_scalar_to + 200,700 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs:__rustc::__rust_realloc + 200,000 ( 0.27%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs:::write_model::<&mut alloc::vec::Vec>'2 + 200,000 ( 0.27%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attribute::<(&str, &str)> + 192,225 ( 0.26%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs:::format_scalar_to + 175,700 ( 0.24%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs:::finish_grow + 168,725 ( 0.23%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs:::format_scalar_to + 150,525 ( 0.21%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs:>::reserve::do_reserve_and_handle:: + 150,000 ( 0.20%) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs:::format_scalar_to + 150,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs:::write_model::<&mut alloc::vec::Vec>'2 + 150,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs:::push_attr + 150,000 ( 0.20%) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs:::write_model::<&mut alloc::vec::Vec>'2 + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-valgrind.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-valgrind.txt new file mode 100644 index 0000000..ba06ebf --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-valgrind.txt @@ -0,0 +1,12 @@ +==394749== Callgrind, a call-graph generating cache profiler +==394749== Copyright (C) 2002-2017, and GNU GPL'd, by Josef Weidendorfer et al. +==394749== Using Valgrind-3.26.0 and LibVEX; rerun with -h for copyright info +==394749== Command: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics write 1000 25 instructions +==394749== Parent PID: 388927 +==394749== +==394749== For interactive control, run 'callgrind_control -h'. +==394749== +==394749== Events : Ir +==394749== Collected : 73268130 +==394749== +==394749== I refs: 73,268,130 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000.callgrind b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000.callgrind new file mode 100644 index 0000000..f25e677 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000.callgrind @@ -0,0 +1,1873 @@ +# callgrind format +version: 1 +creator: callgrind-3.26.0 +pid: 394749 +cmd: benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics write 1000 25 instructions +part: 1 + + +desc: I1 cache: +desc: D1 cache: +desc: LL cache: + +desc: Timerange: Basic block 0 - 27961426 +desc: Trigger: Program termination + +positions: line +events: Ir +summary: 73268130 + + +ob=(2) /usr/lib/x86_64-linux-gnu/libc.so.6 +fl=(2) ??? +fn=(4226) malloc +0 400 +cfn=(4232) 0x00000000000b2400 +calls=4089 0 +0 10525 +0 650725 + +fn=(4460) 0x00000000000b4180 +0 1182900 +cfn=(4232) +calls=163 0 +0 31900 +0 1675 +cfn=(4502) 0x00000000000b2300 +calls=2112 0 +0 8425 +0 1050 +cfn=(4942) 0x00000000000b0f70 +calls=109 0 +0 1650 +0 1325 +cob=(3) ??? +cfi=(3) ??? +cfn=(4486) 0x0000000004b296a0 +calls=162 0 +0 620850 +0 600 +cfn=(4502) +calls=162 0 +0 13900 +0 200 + +fn=(4128) (below main) +cfn=(4162) 0x000000000002a580 +calls=1 0 +0 73268130 + +fn=(4966) 0x0000000000198400 +0 103400 + +fn=(4458) realloc +0 2685850 +cfn=(4460) +calls=38275 0 +0 1864475 +0 276925 + +fn=(4942) +0 8275 + +fn=(4502) +0 2100 +cfn=(4508) 0x00000000000b20e0 +calls=2274 0 +0 19350 +0 875 + +fn=(4868) free +0 300 +cfn=(4508) +calls=4021 0 +0 3175 +0 825625 + +fn=(4508) +0 18350 +cfn=(4942) +calls=721 0 +0 3050 +0 1125 + +fn=(4488) 0x0000000000197a00 +0 4801200 + +fn=(4162) +cob=(6) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/target/release/xml-diagnostics +cfi=(6) ??? +cfn=(4176) main +calls=1 0 +0 73268130 + +fn=(4232) +0 20825 +cfn=(4942) +calls=36 0 +0 775 +0 15950 +cfn=(4942) +calls=749 0 +0 2800 +0 2075 + +ob=(3) +fl=(3) +fn=(4486) +0 200 +cob=(2) +cfi=(2) +cfn=(4488) +calls=208 0 +0 620650 + +ob=(6) +fl=(32) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/raw_vec/mod.rs +fn=(5228) ::finish_grow +544 201400 +fi=(10) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/uint_macros.rs +3212 201400 +fi=(47) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/intrinsics/mod.rs +478 75525 +0 25175 +fe=(32) +631 25175 +fi=(10) +1401 25175 +fi=(23) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/alloc.rs +228 125875 +cfi=(24) /home/bailey/github/PolyXML/benchmarks/rust-runtime-investigation/target/selected/src/main.rs +cfn=(5538) __rustc::__rust_realloc +calls=36276 41 +* 4179875 +fi=(27) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/result.rs +965 50350 ++1 75525 +fe=(32) +0 50350 +564 151050 +-20 200000 +fi=(10) +3212 200000 +fi=(47) +478 75000 +fe=(32) +631 50000 +fi=(10) +1401 25000 +fi=(23) +228 125000 +cfi=(24) +cfn=(5538) +calls=36002 41 +* 1400000 +fi=(27) +965 50000 ++1 75000 +fe=(32) +0 50000 +564 150000 + +fn=(5530) >::reserve::do_reserve_and_handle:: +658 100700 +512 50350 +fi=(10) +938 25175 +fi=(47) +478 25175 +0 25175 +fe=(32) +523 50350 +fi=(19) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/cmp.rs +1051 50350 +fe=(32) +159 176225 +fi=(19) +1051 75525 +fe=(32) +529 100700 +cfn=(5228) +calls=36258 +15 +* 5186875 +fi=(27) +2177 50350 ++1 25175 +fe=(32) +773 25175 ++1 25175 +668 100700 +-10 75000 +fi=(10) +938 25000 +fi=(47) +478 25000 +0 25000 +fe=(32) +523 50000 +fi=(19) +1051 125000 +fe=(32) +529 175000 +cfn=(5228) +calls=36004 +15 +* 2400000 +fi=(27) +2177 50000 ++1 25000 +fe=(32) +773 25000 ++1 25000 +668 100000 + +fl=(94) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/attributes.rs +fn=(6256) >::from +376 75000 ++2 50000 ++1 50000 +fi=(107) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/escape.rs +168 50000 +cfn=(6258) quick_xml::escape::_escape::::{closure#0}, &str> +calls=36000 +33 +* 1722500 +* 25000 +fe=(94) +377 25000 ++4 100000 + +fl=(26) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/alloc/unix.rs +fn=(5682) __rustc::__rust_dealloc +65 25000 +cob=(2) +cfi=(2) +cfn=(4868) +calls=42043 -65 +* 825000 + +fl=(45) /home/bailey/github/PolyXML/crates/polyxml-core/src/schema.rs +fn=(6196) ::matches_variant +182 200200 +fi=(14) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/non_null.rs +454 25025 +fi=(13) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/sync/atomic.rs +3994 25025 +fi=(97) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/sync/rwlock/futex.rs +54 50050 ++45 25025 +fi=(13) +4149 25025 +fi=(97) +97 25025 +fi=(13) +3994 25025 +fi=(33) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs +1865 25025 +fi=(14) +1663 50050 +fi=(50) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/iter/macros.rs +180 25025 +0 75075 +fi=(13) +4049 25025 +fi=(97) +111 25025 ++7 100100 +fe=(45) ++73 225225 + +fn=(6178) ::variants +143 350 +fi=(14) +454 50 +fi=(59) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/sync.rs +2454 50 +fi=(13) +3994 50 +fi=(97) +54 100 ++45 50 +fi=(13) +4149 50 +fi=(97) +97 50 +fi=(13) +3994 50 +fi=(33) +1865 50 +fi=(10) +3212 350 +fi=(47) +478 100 +fi=(32) +-17 100 +fi=(121) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/take.rs +0 50 +fi=(36) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/slice.rs +440 200 +fi=(13) +4049 50 +fi=(97) +111 50 ++7 200 +fe=(45) ++30 450 + +fl=(24) +fn=(5092) __rustc::__rust_alloc +41 25025 +fi=(13) +3994 25025 +762 25025 +fe=(24) +16 25025 +fi=(25) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/alloc.rs +161 100100 +fi=(26) +30 50050 ++1 50050 +cob=(2) +cfi=(2) +cfn=(4226) +calls=46080 -31 +* 661650 +fe=(24) + +fn=(5538) +41 50175 +fi=(13) +3994 50175 +762 50175 +fe=(24) +33 50175 +fi=(89) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/alloc/global.rs +-33 250875 +405 100350 +fi=(26) +70 100350 ++1 100350 +cob=(2) +cfi=(2) +cfn=(4458) +calls=72278 -71 +* 4827250 +fe=(24) + +fn=(6412) measured_region +79 9 +fi=(19) +2144 1 +fi=(34) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/range.rs +1100 1 +0 8 +fi=(26) +0 3 +fi=(19) +2144 25 +fi=(34) +1100 25 +fi=(131) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/hint.rs +491 50 +fe=(24) +91 175 +cfi=(111) /home/bailey/github/PolyXML/crates/polyxml-core/src/lib.rs +cfn=(6154) polyxml::serialize +calls=25 -51 +* 73263400 +fi=(27) +1230 50 ++1 100 +fi=(131) +491 50 +fi=(32) +631 50 +425 25 +fi=(26) +65 25 +cob=(2) +cfi=(2) +cfn=(4868) +calls=25 -65 +* 4100 +* 25 +fe=(24) ++29 8 + +fn=(5130) xml_diagnostics::main +cfn=(6412) +calls=1 79 +70 73268130 + +fl=(122) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/writer.rs +fn=(6214) >>::write_event:: +262 1600400 +fi=(142) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/convert/mod.rs +792 600150 +fe=(122) +264 600150 ++1 300100 ++53 75025 +0 75025 +318 75025 +-31 150000 ++26 50000 +fi=(32) +616 50000 +fi=(33) +1461 50000 +fi=(10) +2689 50000 +fi=(32) +764 50000 +-94 50000 +fi=(33) +2981 99850 +0 50000 +fi=(20) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mut_ptr.rs +970 50000 +fi=(18) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ptr/mod.rs +573 150000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=72000 0 +* 705300 +fi=(33) +2986 100000 +fe=(122) +0 250000 +272 300100 +fi=(41) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs +765 150050 +fi=(33) +1461 75025 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(32) +616 75025 +fi=(10) +2689 150050 +fi=(32) +764 75025 +-94 75025 +fi=(33) +2981 149900 +0 75025 +fi=(20) +970 150050 +fi=(18) +573 150050 +cob=(2) +cfi=(2) +cfn=(4488) +calls=108036 0 +* 1075375 +fi=(32) ++43 75025 +fi=(33) +2986 150050 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(41) +765 225075 +fi=(18) ++82 275100 +fe=(122) +0 75025 +fi=(32) +616 75025 +fi=(33) +1461 75025 +fi=(10) +2689 75025 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(32) +616 75025 +fi=(10) +2689 150050 +fi=(32) +764 75025 +-94 75025 +fi=(33) +2981 150050 +0 75025 +fi=(20) +970 150050 +fi=(18) +573 150050 +cob=(2) +cfi=(2) +cfn=(4488) +calls=108036 0 +* 1125375 +fi=(32) ++43 75025 +fi=(33) +2986 150050 +fi=(32) +764 75025 +-94 75025 +-59 75025 +fi=(18) +-38 75025 +fi=(33) +2986 150050 +fi=(18) +847 300100 +fe=(122) +0 100000 +cfi=(26) +cfn=(5682) +calls=36000 65 +0 850000 +fi=(41) +765 400100 +fe=(122) +308 1800450 +fi=(32) +672 450 +cfn=(5530) +calls=108 -14 +* 660025 +fi=(33) +3101 75 +2981 75 +fi=(32) +672 150 +cfn=(5530) +calls=36 -14 +* 18650 +fi=(33) +3101 50 +0 75 +fi=(32) +672 450 +cfn=(5530) +calls=108 -14 +* 39500 +fi=(33) +3101 150 +2981 75 +fe=(122) + +fl=(38) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/converts.rs +fn=(5180) core::str::converts::from_utf8 +89 750125 +fi=(39) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/str/validations.rs ++44 450075 ++12 300050 +0 1050175 +145 250 ++19 150150 ++1 300300 +fi=(10) +2689 300300 +3875 150150 +fi=(39) +222 150150 ++23 250 +-21 300050 ++17 300050 +0 150025 +241 1175200 ++1 587600 +-1 1325225 +fe=(38) +94 600100 +-94 150025 +98 600100 + +fl=(107) +fn=(6290) quick_xml::escape::_escape::::{closure#0}, &str> +201 500000 ++3 50000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +0 250000 +180 250000 +0 150000 +fi=(14) +1663 675100 +fi=(50) +385 337550 +fi=(14) +1663 337550 +fi=(50) +180 337550 +379 675100 +fe=(107) +109 337550 +0 712650 +218 250000 ++7 200000 ++2 450000 + +fn=(6258) +201 225000 ++3 50000 +fi=(20) +970 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 225000 +fi=(14) +1663 144500 +fi=(50) +385 72250 +fi=(14) +1663 144500 +fi=(50) +379 144500 +fe=(107) +169 72250 +0 144500 +218 75000 ++7 125000 ++2 225000 + +fl=(100) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/events/mod.rs +fn=(6244) ::push_attribute::<(&str, &str)> +256 175000 +fi=(101) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/borrow.rs ++28 75000 +fi=(32) +611 25000 +fi=(126) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/char/methods.rs +2558 25000 +fi=(40) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/string.rs +1440 25000 +fi=(33) +2224 75000 +fi=(142) +781 50000 +cfi=(94) +cfn=(6256) +calls=36000 376 +* 2097500 +fe=(100) +261 75000 +cfn=(6266) ::push_attr +calls=36000 +41 +* 5899500 ++1 200000 +fi=(101) ++23 50000 +fi=(47) +478 25000 +fi=(32) +0 25000 +461 25000 +0 100000 +cfi=(6) +cfn=(5090) __rustc::__rust_no_alloc_shim_is_unstable_v2 +calls=36000 0 +0 25000 +0 25000 +fi=(23) +130 75000 +cfi=(24) +cfn=(5092) +calls=36000 -89 +* 950000 +fi=(32) +470 50000 +fi=(36) +0 25000 +fi=(18) +573 100000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 375000 +* 50000 +fi=(101) +286 75000 +fi=(32) +672 175000 +cfn=(5530) +calls=36000 -14 +* 5375000 +* 75000 +fe=(100) + +fn=(6266) +302 225000 +fi=(101) +-18 75000 +fi=(33) +1461 50000 +fi=(103) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.42.0/src/name.rs +222 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +0 25000 +fi=(20) +970 25000 +fi=(18) +573 75000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 450000 +fi=(33) +2986 50000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +-59 25000 +fi=(18) +-38 25000 +fi=(33) +2986 50000 +fi=(101) +0 75000 +fi=(10) +2689 50000 +fi=(32) +764 25000 +-94 25000 +fi=(33) +2981 50000 +fi=(20) +970 50000 +fi=(18) +573 50000 +cob=(2) +cfi=(2) +cfn=(4488) +calls=36000 0 +* 449500 +fi=(33) +2986 50000 +fi=(32) +764 25000 +-94 25000 +fi=(126) +2558 25000 +fi=(40) +1440 25000 +fi=(33) +2224 25000 +fi=(18) +847 75000 +fe=(100) +309 200000 +fi=(32) +672 100000 +cfn=(5530) +calls=36000 -14 +* 3125000 +-56 25000 +fi=(33) +3101 50000 +fe=(100) + +fl=(111) +fn=(6154) +40 50 +fi=(120) /home/bailey/github/PolyXML/crates/polyxml-core/src/serializer.rs +180 125 +cfn=(6156) ::serialize_with_options +calls=36 +3 +* 73263125 +* 25 +fe=(111) +47 75 + +fl=(6) +fn=(5090) +0 25025 + +fn=(4126) (below main) +cob=(2) +cfi=(2) +cfn=(4128) +calls=1 0 +0 73268130 + +fn=(4176) +cfi=(8) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/rt.rs +cfn=(4178) std::rt::lang_start_internal +calls=1 152 +0 73268130 + +fl=(30) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/std/src/sys/backtrace.rs +fn=(5128) std::sys::backtrace::__rust_begin_short_backtrace:: +fi=(143) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/function.rs +cfi=(24) +cfn=(5130) +calls=1 43 +250 73268130 +fe=(30) + +fl=(8) +fn=(4178) +fi=(143) +cfn=(5126) std::rt::lang_start::<()>::{closure#0} +calls=1 206 +287 73268130 +fe=(8) + +fn=(5126) +cfi=(30) +cfn=(5128) +calls=1 162 +206 73268130 + +fl=(120) +fn=(6156) +183 350 +cfi=(6) +cfn=(5090) +calls=36 0 +* 25 +fi=(23) +-53 75 +cfi=(24) +cfn=(5092) +calls=36 -89 +* 11950 +fi=(32) +470 50 +fi=(33) +969 75 +fe=(120) +192 50 +fi=(41) +0 25 +743 25 +0 25 +fi=(122) +124 75 +fe=(120) ++73 50 +0 50 +199 75 +cfn=(6166) ::build +calls=36 22 +* 7000 +fi=(41) +743 75 +0 25 +743 75 +0 50 +fe=(120) +202 225 +cfn=(6194) ::write_model::<&mut alloc::vec::Vec> +calls=36 302 +* 73242200 +* 25 +fi=(27) +2177 50 +fe=(120) +212 150 +fi=(18) +847 125 +fe=(120) +0 25 +213 200 + +fn=(6166) +22 250 +fi=(33) +462 100 +fe=(120) +27 50 +cfn=(6168) ::collect_namespaces +calls=36 +60 +* 6150 +fi=(33) +3126 25 +fe=(120) +29 25 +fi=(41) +709 50 +fe=(120) +0 25 +30 25 +fi=(32) +425 50 +631 25 +fe=(120) +85 225 + +fn=(6232) ::format_scalar_to +216 600000 ++4 300000 +0 75000 +220 225000 ++7 25000 +fi=(144) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/f64.rs +1264 25000 +886 100000 +fi=(115) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/num.rs +1037 50000 +fi=(32) +611 50000 +fe=(120) +223 25000 +fi=(19) +2144 25000 +fi=(145) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/api.rs +50 25000 +fi=(123) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/jeaiii.rs +310 50000 ++2 50000 +118 22500 ++2 45000 ++1 45000 +fi=(124) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-util-1.0.7/src/digit.rs +-60 22500 +fi=(123) ++16 22500 +-39 45000 ++76 67500 +fi=(44) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/index.rs +219 22500 +fi=(123) +68 22500 ++20 22500 ++1 22500 +-21 22500 ++21 45000 +314 22500 +0 125000 +fi=(128) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/ops/bit.rs +178 50000 +fi=(19) +2105 25000 +fi=(125) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/write.rs +121 25000 +fi=(10) +0 25000 +fi=(127) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/algorithm.rs +292 50025 +0 50 +fi=(128) +282 50 +fi=(10) +154 25 +fi=(146) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-integer-1.0.6/src/decimal.rs +32 50 +fi=(44) +186 25 +fi=(19) +2150 25 +fi=(146) +108 25 +fi=(127) +-54 25 +fi=(147) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/shared.rs +181 100 +fi=(128) +282 49950 +fi=(10) +154 24975 +fi=(146) +32 49950 +fi=(44) +186 24975 +fi=(19) +2150 24975 +fi=(146) +108 24975 +fi=(127) +-54 24975 +fi=(147) +181 99900 +fi=(123) +0 25000 +fi=(147) +186 50000 +fi=(127) +53 50000 +fi=(123) +310 50000 ++2 24500 +118 9375 ++2 18750 ++1 28125 +fi=(124) +-60 3350 +fi=(123) ++16 3350 +-39 6700 ++76 10050 +fi=(44) +219 3350 +fi=(123) +68 3350 ++20 3350 ++1 3350 +-21 3350 ++21 6700 +fi=(127) +225 3350 ++3 9500 +fi=(44) +0 99900 +fi=(127) +352 24975 +0 49950 +fi=(128) +178 24975 +fi=(115) +1057 74925 +fi=(19) +2105 24975 +fi=(115) +1057 99900 +fi=(148) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/num/int_macros.rs +2261 24975 +fi=(127) +875 24975 +456 49950 +fi=(44) +219 24975 +fi=(148) +2261 24975 +fi=(44) +219 49950 +fi=(149) /home/bailey/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lexical-write-float-1.0.6/src/index.rs +13 24975 +fi=(127) +883 24975 +457 24975 +1381 149850 +fi=(149) +13 24975 +fi=(127) +461 49950 ++12 74925 +836 99900 +-6 74925 ++7 49950 +-7 99900 +968 24975 +fi=(10) +2728 24975 +fi=(127) +484 24975 ++13 49950 +-51 24975 ++54 24975 +fi=(123) +314 5000 +fi=(44) +-95 2250 +fi=(123) +68 2250 ++20 4500 +fe=(120) +-88 12750 +fi=(123) +319 38250 ++2 25500 +fi=(124) +61 250 +fi=(123) ++16 500 +314 250 +0 4500 +314 8625 +fi=(44) +-95 2350 +fi=(123) +68 4700 ++20 2350 ++1 4700 +fi=(127) +225 2350 ++3 7000 +fi=(44) +-9 6025 +fi=(123) +68 12050 ++20 6025 ++1 6025 +-51 12050 ++76 18075 +-46 6025 ++20 6025 ++1 6025 +-21 6025 ++21 12050 +fi=(127) +225 6025 ++3 12675 +fi=(123) ++98 25500 +fi=(124) +61 525 +fi=(123) ++16 525 +fi=(127) +225 1575 +0 24975 +1398 74925 +535 24975 +1404 149850 ++2 124875 +0 24975 +fi=(10) +2728 24975 +fi=(127) +1088 24975 +1412 74925 +0 36050 +fi=(10) +2728 36050 +fi=(127) +1088 36050 +1412 108150 +fi=(10) +2728 24975 +fi=(127) +1088 24975 +1421 124875 +-32 49950 +fi=(123) +328 38250 +118 12750 ++2 25500 ++1 25500 +fi=(124) +-60 10250 +fi=(123) ++16 10250 +-39 30750 ++76 30750 +fi=(44) +219 10250 +fi=(123) +68 10250 ++20 10250 ++1 10250 +-21 10250 ++21 10250 +-51 10250 ++76 30750 +-46 10250 ++20 10250 ++1 10250 +-21 10250 ++21 20500 +fi=(127) +225 10250 ++3 20500 ++19 37500 +fi=(44) +102 18750 +fi=(34) +1142 37500 +0 18750 +1142 18750 +fi=(19) +2144 18750 +0 18750 +2144 18750 +fi=(127) +251 56250 +fi=(34) +1142 18750 +fi=(19) +2144 12500 +fi=(127) +251 37500 +fi=(34) +1142 12500 +fi=(127) +248 18750 ++7 18750 +fi=(125) +154 18750 +fi=(10) +1092 18750 +fi=(44) +219 2500 +fi=(123) +68 5000 ++20 2500 ++1 2500 +-51 7500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 2500 +-51 2500 ++76 7500 +-46 2500 ++20 2500 ++1 2500 +-21 2500 ++21 5000 +fi=(127) +225 2500 ++3 5000 +fi=(10) +1096 12500 +fi=(44) +102 12500 +fi=(150) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/slice/specialize.rs +-68 18750 +cob=(2) +cfi=(2) +cfn=(4966) +calls=9000 -34 +* 103400 +fi=(127) +236 6250 ++3 6250 +fi=(125) +-85 12500 +0 31250 +cfi=(38) +cfn=(5180) +calls=9000 89 +0 403500 +0 175000 +cfi=(38) +cfn=(5180) +calls=63000 89 +0 2609250 +fi=(27) +714 100000 ++1 50000 +fe=(120) +0 100000 +234 400000 +0 50000 +234 200000 + +fn=(6194) +302 300 ++9 125 +0 25 +324 100 +0 25 +fi=(14) +454 25 +fi=(59) +2454 75 +fe=(120) +325 75 +cfi=(45) +cfn=(6196) +calls=36 182 +* 950 +* 50 +fi=(50) +0 75 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 575 +fi=(41) +634 50 +fe=(120) +353 50 +0 25 +251 350 ++2 50 +-2 50 +fi=(27) +0 50 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25 +fi=(41) +634 50 +fe=(120) +361 25 +fi=(23) +0 75 +fe=(120) +409 25 +cfi=(38) +cfn=(5180) +calls=36 89 +* 2600 +fi=(27) +0 50 +2177 50 +fi=(111) +0 25 +fe=(120) +410 50 ++3 75 +fi=(100) +124 100 +0 25 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 500 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +434 125 ++33 50 ++21 200 +cfi=(122) +cfn=(6214) +calls=36 262 +* 2050 +* 25 +0 25 +fi=(27) +965 50 +fi=(111) +0 25 +fe=(120) +492 50 ++30 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 475 +fe=(120) +616 125 +0 25 +345 50 +fi=(44) +184 50 ++2 50 +fi=(41) +743 50 +0 50 +fi=(129) /home/bailey/github/PolyXML/crates/polyxml-core/src/value.rs +59 25 +fe=(120) +618 25 +fi=(41) +743 75 +fi=(27) +0 25 +fi=(41) +743 50 +fi=(33) +0 25 +fe=(120) +624 225 +0 50 +656 50 +fi=(33) +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 25075 +fi=(14) +1663 25000 +fi=(50) +180 25000 +fi=(28) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/boxed.rs +2415 25000 +fe=(120) +658 175000 +fi=(41) ++85 50000 +fi=(14) +454 25000 +fi=(41) +743 50000 +fi=(23) +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fi=(59) +2454 25000 +fe=(120) +714 200000 +cfn=(6195) ::write_model::<&mut alloc::vec::Vec>'2 +calls=36000 302 +* 72453100 +* 25000 +fi=(27) +2177 50000 +fi=(118) /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/adapters/enumerate.rs +0 50 +fi=(14) +1663 50 +fi=(50) +180 25 +fi=(101) +350 50 +fe=(120) +756 175 +cfi=(122) +cfn=(6214) +calls=36 262 +* 2025 +fi=(27) +965 50 +fe=(120) +760 200 +0 25 +759 25 ++1 25 +fi=(18) ++87 50 +fi=(23) +0 25 +fi=(18) +847 75 +fe=(120) + +fn=(6195) +302 300000 ++9 125000 +0 25000 +324 100000 +0 25000 +fi=(14) +454 25000 +fi=(59) +2454 75000 +fe=(120) +325 75000 +cfi=(45) +cfn=(6196) +calls=36000 182 +* 950000 +* 50000 +fi=(50) +0 75000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 575000 +fi=(41) +634 150000 +fe=(120) +353 150000 +0 75000 +251 750000 +353 150000 +fi=(27) +0 150000 +fi=(14) +1663 75000 +fi=(50) +180 75000 +0 25000 +fi=(41) +634 50000 +fe=(120) +361 25000 +fi=(23) +0 75000 +fe=(120) +409 25000 +cfi=(38) +cfn=(5180) +calls=36000 89 +* 1475000 +fi=(27) +0 50000 +2177 50000 +fi=(111) +0 25000 +fe=(120) +410 50000 ++3 75000 +fi=(100) +124 100000 +0 25000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 550000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 100000 +fi=(14) +1663 50000 +fi=(50) +180 50000 +fe=(120) +434 375000 +0 25000 +345 50000 +fi=(44) +184 50000 ++2 50000 +fi=(41) +743 50000 +0 50000 +fi=(129) +59 25000 +fe=(120) +436 25000 +0 25000 +fi=(32) +611 25000 +fi=(33) +1865 25000 +fe=(120) +437 50000 +cfi=(38) +cfn=(5180) +calls=36000 89 +* 1225000 +fi=(27) +0 50000 +2177 50000 +0 25000 +fe=(120) +410 25000 ++28 25000 ++3 75000 +-3 25000 +0 25000 +443 100000 ++1 100000 +cfn=(6232) +calls=36000 216 +* 2805750 +* 125000 +295 25000 +-9 100000 +445 50000 +295 150000 +-9 75000 +fi=(101) ++64 25000 +fe=(120) ++96 175000 +cfi=(100) +cfn=(6244) +calls=36000 256 +* 16322000 +fi=(18) +847 125000 +fe=(120) +286 125000 +467 50000 ++21 200000 +cfi=(122) +cfn=(6214) +calls=36000 262 +* 2944050 +* 25000 +0 25000 +fi=(27) +965 50000 +fi=(111) +0 25000 +fe=(120) +492 50000 ++30 50000 +fi=(33) +1865 25000 +fi=(14) +1663 25000 +fi=(50) +180 25000 +0 475000 +fe=(120) +616 375000 +0 50000 +345 100000 +fi=(44) +184 100000 ++2 100000 +fi=(41) +743 100000 +0 100000 +fi=(129) +59 50000 +fe=(120) +618 50000 +fi=(41) +743 150000 +fi=(27) +0 50000 +fi=(41) +743 100000 +fi=(33) +0 50000 +fe=(120) +624 450000 +fi=(41) +0 100000 +fe=(120) +626 200000 ++1 200000 +cfn=(6232) +calls=72000 216 +* 8087575 +* 150000 +0 100000 +627 100000 +fi=(32) +-16 50000 +fi=(33) +1865 50000 +fe=(120) +628 250000 +cfn=(6284) ::validate_scalar +calls=72000 285 +* 1150000 +fi=(27) +2177 100000 +fi=(32) +611 50000 +fi=(33) +1865 50000 +fe=(120) +629 100000 +cfi=(38) +cfn=(5180) +calls=72000 89 +* 3075000 +fi=(27) +0 100000 +2177 100000 +0 50000 +fe=(120) +410 50000 +630 50000 +fi=(33) +0 50000 +fe=(120) +633 150000 ++4 400000 +cfi=(122) +cfn=(6214) +calls=72000 262 +* 4121050 +fi=(27) +965 100000 +fi=(107) +108 200000 +cfn=(6290) +calls=72000 +93 +* 5613050 +fi=(100) +564 250000 +fe=(120) ++80 200000 +cfi=(122) +cfn=(6214) +calls=72000 262 +* 3765775 +fi=(27) +965 100000 +fe=(120) +649 350000 +cfi=(122) +cfn=(6214) +calls=72000 262 +* 4068850 +fi=(27) +965 100000 +fe=(120) +653 50000 +fi=(18) +847 100000 +fi=(23) +0 50000 +fi=(18) +847 100000 +fi=(118) +0 150000 +fi=(14) +1663 150000 +fi=(50) +180 75000 +fi=(101) +350 50000 +fe=(120) +756 175000 +cfi=(122) +cfn=(6214) +calls=36000 262 +* 2025000 +fi=(27) +965 50000 +fe=(120) +760 200000 +0 25000 +759 25000 ++1 25000 +fi=(18) ++87 50000 +fi=(23) +0 25000 +fi=(18) +847 75000 +fe=(120) + +fn=(6284) +285 200000 ++10 50000 +-9 150000 ++9 200000 +-9 350000 ++13 50000 ++1 150000 + +fn=(6168) +87 225 ++1 100 +fi=(33) +-88 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fi=(14) +454 25 +fi=(59) +2454 50 +fe=(120) +0 25 +cfn=(6169) ::collect_namespaces'2 +calls=36 87 +0 3225 +0 25 +fi=(14) +1663 25 +fi=(50) +180 25 +fe=(120) +-86 50 ++5 225 +fi=(28) +2415 25 +fe=(120) +102 75 +fi=(14) +454 25 +fe=(120) +102 25 +0 25 +109 50 +0 50 +125 25 +cfi=(45) +cfn=(6178) +calls=36 +18 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +126 25 +fi=(32) +425 50 +631 25 +fe=(120) +134 200 + +fn=(6169) +87 225 ++1 100 +fi=(33) +-88 25 +1865 25 +fi=(14) +1663 25 +fi=(50) +180 25 +0 150 +180 25 +fe=(120) +0 75 +fi=(14) +1663 75 +fi=(50) +180 75 +fe=(120) +-86 150 ++5 525 +-99 25 +109 50 +0 50 +125 25 +cfi=(45) +cfn=(6178) +calls=36 +18 +* 1200 +fi=(33) +3101 25 ++25 50 +fe=(120) +126 25 +fi=(32) +425 50 +631 25 +fe=(120) +134 200 + +ob=(1) /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 +fl=(1) ??? +fn=(0) 0x0000000000023340 +cob=(6) +cfi=(6) +cfn=(4126) +calls=1 0 +0 73268130 + +totals: 73268130 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/prototype-confirmation.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/prototype-confirmation.tar.gz new file mode 100644 index 0000000..8342e60 Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/prototype-confirmation.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/screening.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/screening.tar.gz new file mode 100644 index 0000000..04cda53 Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/screening.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-0.txt new file mode 100644 index 0000000..fba2a82 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-0.txt @@ -0,0 +1,83 @@ +memcap: <=7805 MiB (60% of 13009 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0068 s (65k iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [77.370 µs 77.601 µs 77.867 µs] + thrpt: [2.4128 MiB/s 2.4210 MiB/s 2.4283 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.1241 s (4000 iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [1.2693 ms 1.2748 ms 1.2812 ms] + thrpt: [2.3083 MiB/s 2.3199 MiB/s 2.3298 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 1 (1.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0695 s (3700 iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [1.3542 ms 1.3588 ms 1.3647 ms] + thrpt: [2.3124 MiB/s 2.3224 MiB/s 2.3303 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 6 (6.00%) high mild + 2 (2.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.2574 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.2198 ms 5.2382 ms 5.2600 ms] + thrpt: [2.3724 MiB/s 2.3823 MiB/s 2.3907 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0034 s (69k iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [72.064 µs 72.620 µs 73.345 µs] + thrpt: [2.5615 MiB/s 2.5871 MiB/s 2.6070 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 3 (3.00%) high mild + 10 (10.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0118 s (4300 iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [1.1635 ms 1.1708 ms 1.1790 ms] + thrpt: [2.5084 MiB/s 2.5259 MiB/s 2.5417 MiB/s] +Found 16 outliers among 100 measurements (16.00%) + 2 (2.00%) high mild + 14 (14.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0941 s (4000 iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [1.2602 ms 1.2666 ms 1.2743 ms] + thrpt: [2.4765 MiB/s 2.4914 MiB/s 2.5041 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.3959 s (1100 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [4.9792 ms 5.0260 ms 5.0781 ms] + thrpt: [2.4574 MiB/s 2.4829 MiB/s 2.5062 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 4 (4.00%) high mild + 2 (2.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-1.txt new file mode 100644 index 0000000..6c9d7c6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-1.txt @@ -0,0 +1,83 @@ +memcap: <=7878 MiB (60% of 13130 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0049 s (66k iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [78.161 µs 78.953 µs 79.889 µs] + thrpt: [2.3517 MiB/s 2.3796 MiB/s 2.4037 MiB/s] +Found 16 outliers among 100 measurements (16.00%) + 7 (7.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.0684 s (4000 iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [1.2652 ms 1.2765 ms 1.2910 ms] + thrpt: [2.2908 MiB/s 2.3167 MiB/s 2.3375 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 5 (5.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0325 s (3700 iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [1.3414 ms 1.3481 ms 1.3563 ms] + thrpt: [2.3268 MiB/s 2.3409 MiB/s 2.3525 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.2297 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.1693 ms 5.1940 ms 5.2254 ms] + thrpt: [2.3881 MiB/s 2.4026 MiB/s 2.4140 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 6 (6.00%) high mild + 2 (2.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0056 s (70k iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [71.187 µs 71.663 µs 72.202 µs] + thrpt: [2.6021 MiB/s 2.6216 MiB/s 2.6392 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 5 (5.00%) high mild + 8 (8.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0647 s (4300 iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [1.1708 ms 1.1788 ms 1.1883 ms] + thrpt: [2.4887 MiB/s 2.5088 MiB/s 2.5260 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 4 (4.00%) high mild + 11 (11.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0699 s (4100 iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [1.2243 ms 1.2297 ms 1.2362 ms] + thrpt: [2.5528 MiB/s 2.5662 MiB/s 2.5776 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.3378 s (1100 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [4.8544 ms 4.8938 ms 4.9400 ms] + thrpt: [2.5261 MiB/s 2.5499 MiB/s 2.5706 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-2.txt new file mode 100644 index 0000000..b91d030 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-2.txt @@ -0,0 +1,83 @@ +memcap: <=7884 MiB (60% of 13140 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0055 s (66k iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [77.751 µs 78.357 µs 79.056 µs] + thrpt: [2.3765 MiB/s 2.3977 MiB/s 2.4164 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 4 (4.00%) high mild + 11 (11.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.0169 s (3900 iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [1.2753 ms 1.2804 ms 1.2866 ms] + thrpt: [2.2986 MiB/s 2.3096 MiB/s 2.3189 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 7 (7.00%) high mild + 4 (4.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0535 s (3700 iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [1.3524 ms 1.3589 ms 1.3668 ms] + thrpt: [2.3087 MiB/s 2.3222 MiB/s 2.3334 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.3674 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.2093 ms 5.2401 ms 5.2776 ms] + thrpt: [2.3645 MiB/s 2.3814 MiB/s 2.3955 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 6 (6.00%) high mild + 8 (8.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0015 s (69k iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [72.042 µs 72.397 µs 72.842 µs] + thrpt: [2.5792 MiB/s 2.5951 MiB/s 2.6078 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0448 s (4200 iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [1.1821 ms 1.1873 ms 1.1932 ms] + thrpt: [2.4784 MiB/s 2.4909 MiB/s 2.5018 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 7 (7.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0424 s (4000 iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [1.2430 ms 1.2491 ms 1.2570 ms] + thrpt: [2.5106 MiB/s 2.5263 MiB/s 2.5387 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.0083 s (1000 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [4.9132 ms 4.9260 ms 4.9401 ms] + thrpt: [2.5260 MiB/s 2.5332 MiB/s 2.5399 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-build.txt new file mode 100644 index 0000000..dda2385 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline-build.txt @@ -0,0 +1,3 @@ +memcap: <=7883 MiB (60% of 13139 MiB available) [systemd MemoryMax, swap off] + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-baseline) + Finished `bench` profile [optimized] target(s) in 2.36s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/baseline.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-0.txt new file mode 100644 index 0000000..ece199d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-0.txt @@ -0,0 +1,83 @@ +memcap: <=7883 MiB (60% of 13138 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0000 s (2.2M iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [2.3064 µs 2.3203 µs 2.3380 µs] + thrpt: [80.358 MiB/s 80.968 MiB/s 81.457 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.0008 s (144k iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [34.472 µs 34.653 µs 34.876 µs] + thrpt: [84.796 MiB/s 85.340 MiB/s 85.789 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 3 (3.00%) high mild + 10 (10.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0173 s (24k iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [205.46 µs 206.78 µs 208.31 µs] + thrpt: [15.149 MiB/s 15.261 MiB/s 15.359 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.2379 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.2160 ms 5.2547 ms 5.3013 ms] + thrpt: [2.3539 MiB/s 2.3748 MiB/s 2.3924 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0000 s (6.4M iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [775.75 ns 778.71 ns 782.19 ns] + thrpt: [240.19 MiB/s 241.26 MiB/s 242.18 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0010 s (388k iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [12.848 µs 12.945 µs 13.058 µs] + thrpt: [226.47 MiB/s 228.46 MiB/s 230.17 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0017 s (145k iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [34.459 µs 34.625 µs 34.808 µs] + thrpt: [90.661 MiB/s 91.141 MiB/s 91.578 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 8 (8.00%) high mild + 4 (4.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.0142 s (7300 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [686.74 µs 692.64 µs 699.70 µs] + thrpt: [17.835 MiB/s 18.016 MiB/s 18.171 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 5 (5.00%) high mild + 9 (9.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-1.txt new file mode 100644 index 0000000..71d6e88 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-1.txt @@ -0,0 +1,83 @@ +memcap: <=7884 MiB (60% of 13140 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0001 s (2.2M iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [2.3092 µs 2.3204 µs 2.3332 µs] + thrpt: [80.522 MiB/s 80.965 MiB/s 81.359 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 3 (3.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.0017 s (144k iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [34.380 µs 34.537 µs 34.727 µs] + thrpt: [85.159 MiB/s 85.630 MiB/s 86.019 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0106 s (25k iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [203.39 µs 204.60 µs 206.11 µs] + thrpt: [15.311 MiB/s 15.424 MiB/s 15.516 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.2104 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.2138 ms 5.2538 ms 5.3014 ms] + thrpt: [2.3539 MiB/s 2.3752 MiB/s 2.3934 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0001 s (6.1M iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [793.39 ns 796.46 ns 800.09 ns] + thrpt: [234.81 MiB/s 235.88 MiB/s 236.80 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 3 (3.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0005 s (392k iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [12.635 µs 12.696 µs 12.769 µs] + thrpt: [231.60 MiB/s 232.94 MiB/s 234.07 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 4 (4.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0009 s (145k iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [34.422 µs 34.669 µs 34.988 µs] + thrpt: [90.195 MiB/s 91.025 MiB/s 91.676 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.0066 s (7300 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [683.27 µs 688.29 µs 694.40 µs] + thrpt: [17.971 MiB/s 18.130 MiB/s 18.263 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 3 (3.00%) high mild + 8 (8.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-2.txt new file mode 100644 index 0000000..bda9397 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-2.txt @@ -0,0 +1,83 @@ +memcap: <=7885 MiB (60% of 13141 MiB available) [systemd MemoryMax, swap off] +Benchmarking cache_read/active_patterns/1 +Benchmarking cache_read/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/1: Collecting 100 samples in estimated 5.0001 s (2.2M iterations) +Benchmarking cache_read/active_patterns/1: Analyzing +cache_read/active_patterns/1 + time: [2.3418 µs 2.3702 µs 2.4058 µs] + thrpt: [78.092 MiB/s 79.264 MiB/s 80.226 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 4 (4.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_read/active_patterns/16 +Benchmarking cache_read/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/16: Collecting 100 samples in estimated 5.0030 s (145k iterations) +Benchmarking cache_read/active_patterns/16: Analyzing +cache_read/active_patterns/16 + time: [34.369 µs 34.525 µs 34.749 µs] + thrpt: [85.106 MiB/s 85.657 MiB/s 86.048 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 4 (4.00%) high mild + 3 (3.00%) high severe +Benchmarking cache_read/active_patterns/17 +Benchmarking cache_read/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/17: Collecting 100 samples in estimated 5.0029 s (24k iterations) +Benchmarking cache_read/active_patterns/17: Analyzing +cache_read/active_patterns/17 + time: [205.36 µs 206.63 µs 208.05 µs] + thrpt: [15.168 MiB/s 15.272 MiB/s 15.366 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 5 (5.00%) high mild + 7 (7.00%) high severe +Benchmarking cache_read/active_patterns/64 +Benchmarking cache_read/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_read/active_patterns/64: Collecting 100 samples in estimated 5.2273 s (1000 iterations) +Benchmarking cache_read/active_patterns/64: Analyzing +cache_read/active_patterns/64 + time: [5.2373 ms 5.2702 ms 5.3076 ms] + thrpt: [2.3511 MiB/s 2.3678 MiB/s 2.3827 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe + +Benchmarking cache_write/active_patterns/1 +Benchmarking cache_write/active_patterns/1: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/1: Collecting 100 samples in estimated 5.0000 s (6.1M iterations) +Benchmarking cache_write/active_patterns/1: Analyzing +cache_write/active_patterns/1 + time: [808.79 ns 812.81 ns 817.20 ns] + thrpt: [229.90 MiB/s 231.14 MiB/s 232.29 MiB/s] +Found 5 outliers among 100 measurements (5.00%) + 4 (4.00%) high mild + 1 (1.00%) high severe +Benchmarking cache_write/active_patterns/16 +Benchmarking cache_write/active_patterns/16: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/16: Collecting 100 samples in estimated 5.0010 s (392k iterations) +Benchmarking cache_write/active_patterns/16: Analyzing +cache_write/active_patterns/16 + time: [12.726 µs 12.870 µs 13.069 µs] + thrpt: [226.28 MiB/s 229.79 MiB/s 232.38 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 4 (4.00%) high mild + 8 (8.00%) high severe +Benchmarking cache_write/active_patterns/17 +Benchmarking cache_write/active_patterns/17: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/17: Collecting 100 samples in estimated 5.0014 s (144k iterations) +Benchmarking cache_write/active_patterns/17: Analyzing +cache_write/active_patterns/17 + time: [34.903 µs 35.454 µs 36.130 µs] + thrpt: [87.343 MiB/s 89.007 MiB/s 90.412 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 1 (1.00%) high mild + 9 (9.00%) high severe +Benchmarking cache_write/active_patterns/64 +Benchmarking cache_write/active_patterns/64: Warming up for 3.0000 s +Benchmarking cache_write/active_patterns/64: Collecting 100 samples in estimated 5.0297 s (7300 iterations) +Benchmarking cache_write/active_patterns/64: Analyzing +cache_write/active_patterns/64 + time: [684.12 µs 689.33 µs 695.60 µs] + thrpt: [17.940 MiB/s 18.103 MiB/s 18.241 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 5 (5.00%) high mild + 10 (10.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-build.txt new file mode 100644 index 0000000..75d22c8 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current-build.txt @@ -0,0 +1,3 @@ +memcap: <=7827 MiB (60% of 13046 MiB available) [systemd MemoryMax, swap off] + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-current) + Finished `bench` profile [optimized] target(s) in 2.33s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/current.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/harness.rs new file mode 100644 index 0000000..96494dd --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/harness.rs @@ -0,0 +1,70 @@ +use criterion::{ + criterion_group, criterion_main, BenchmarkId, Criterion, SamplingMode, Throughput, +}; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::{hint::black_box, sync::Arc}; + +// Cycle through more than the admitted cache capacity to compare eviction policies. +// Schema construction and correctness checks remain outside measurement. +fn fixture(patterns: usize) -> (Arc, Vec) { + let mut builder = ModelSchema::builder("Root"); + for i in 0..patterns { + builder = builder.field(FieldSchema::new( + format!("values{i}"), + format!("Value{i}").as_bytes(), + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(ScalarType::Pattern( + Box::new(ScalarType::String), + vec![format!("P{i}-[0-9]{{3}}")], + )))), + )); + } + let schema = builder.build(); + let mut xml = String::from(""); + for _ in 0..8 { + for i in 0..patterns { + xml.push_str(&format!("P{i}-123")); + } + } + xml.push_str(""); + let value = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap(); + for i in 0..patterns { + let values = value.get(&format!("values{i}")).unwrap().as_list().unwrap(); + assert_eq!(values.len(), 8); + assert!(values + .iter() + .all(|value| value.as_str() == Some(format!("P{i}-123").as_str()))); + } + let output = serialize("Root", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml.into_bytes()) +} + +fn benchmarks(c: &mut Criterion) { + for operation in ["cache_read", "cache_write"] { + let mut group = c.benchmark_group(operation); + group.sampling_mode(SamplingMode::Flat); + for patterns in [1, 16, 17, 64] { + let (schema, xml) = fixture(patterns); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_with_input( + BenchmarkId::new("active_patterns", patterns), + &patterns, + |b, _| { + b.iter(|| { + if operation == "cache_read" { + black_box(deserialize(black_box(&xml), Arc::clone(&schema)).unwrap()); + } else { + black_box(serialize("Root", black_box(&value), &schema, None).unwrap()); + } + }); + }, + ); + } + group.finish(); + } +} +criterion_group!(benches, benchmarks); +criterion_main!(benches); diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/metadata.json new file mode 100644 index 0000000..30a54e6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/metadata.json @@ -0,0 +1,19 @@ +{ + "revisions": { + "baseline": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "current": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d" + }, + "core_status": { + "baseline": "", + "current": "" + }, + "sample_size": 100, + "warmup_seconds": 3.0, + "measurement_seconds": 5.0, + "rounds": 3, + "filter": "", + "order": "alternate baseline/current per round", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "cpu": "11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/samples.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/samples.tar.gz new file mode 100644 index 0000000..b19cdbb Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/samples.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/summary.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/summary.json new file mode 100644 index 0000000..8967b82 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-cache-boundaries/summary.json @@ -0,0 +1,570 @@ +{ + "cache_read/active_patterns/1": { + "baseline_ns": 78356.81222900763, + "candidate_ns": 2320.4279190830002, + "delta_percent": -97.03863920305837, + "speedup": 33.76825954583977, + "process_deltas_percent": [ + -97.00991612359202, + -97.06099304464375, + -96.97506930736616 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 77370.01285397552, + "upper_bound": 77866.90797362383 + }, + "point_estimate": 77600.97730886849, + "standard_error": 127.00882124942845 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 78160.7250250379, + "upper_bound": 79889.41736001514 + }, + "point_estimate": 78952.78760242792, + "standard_error": 442.6783565854083 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 77750.85412251911, + "upper_bound": 79056.01933015269 + }, + "point_estimate": 78356.81222900763, + "standard_error": 333.37033798867463 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2306.405427231712, + "upper_bound": 2337.9566279027167 + }, + "point_estimate": 2320.3343104474866, + "standard_error": 8.125487362029338 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2309.2003044241583, + "upper_bound": 2333.1892796416273 + }, + "point_estimate": 2320.4279190830002, + "standard_error": 6.139999878200719 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2341.8150543389193, + "upper_bound": 2405.814931797487 + }, + "point_estimate": 2370.23926288472, + "standard_error": 16.41971875774395 + } + ] + } + }, + "cache_read/active_patterns/16": { + "baseline_ns": 1276524.3425000003, + "candidate_ns": 34536.501128027674, + "delta_percent": -97.29448942114257, + "speedup": 36.9616000696739, + "process_deltas_percent": [ + -97.28157204321526, + -97.29448942114257, + -97.30363895730547 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1269345.62895625, + "upper_bound": 1281180.9252812495 + }, + "point_estimate": 1274761.6159999997, + "standard_error": 3027.4831006584936 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1265182.3018125, + "upper_bound": 1290976.1734875 + }, + "point_estimate": 1276524.3425000003, + "standard_error": 6635.789921621048 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1275307.1147564102, + "upper_bound": 1286562.2085000004 + }, + "point_estimate": 1280441.0346153844, + "standard_error": 2884.164426880222 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34472.352339248435, + "upper_bound": 34876.0824151009 + }, + "point_estimate": 34653.476151704934, + "standard_error": 103.54354257407316 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34380.214768166086, + "upper_bound": 34727.13834256057 + }, + "point_estimate": 34536.501128027674, + "standard_error": 89.04103320566603 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34368.699566298346, + "upper_bound": 34749.0135621547 + }, + "point_estimate": 34525.313232044195, + "standard_error": 99.42334620352003 + } + ] + } + }, + "cache_read/active_patterns/17": { + "baseline_ns": 1358825.9837837839, + "candidate_ns": 206633.65669456057, + "delta_percent": -84.79322156328149, + "speedup": 6.576014796042438, + "process_deltas_percent": [ + -84.78230559582643, + -84.82316244526204, + -84.794215444798 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1354210.2022364868, + "upper_bound": 1364708.5621216213 + }, + "point_estimate": 1358825.9837837839, + "standard_error": 2702.504256583427 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1341446.5449797295, + "upper_bound": 1356269.045810811 + }, + "point_estimate": 1348099.9386486497, + "standard_error": 3815.5145005511654 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1352388.1261554048, + "upper_bound": 1366849.912317567 + }, + "point_estimate": 1358914.7994594593, + "standard_error": 3698.9619656597774 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 205457.91396618835, + "upper_bound": 208309.9180081967 + }, + "point_estimate": 206781.9856967213, + "standard_error": 731.3237495870658 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 203385.7339481707, + "upper_bound": 206108.04806605697 + }, + "point_estimate": 204598.93776422762, + "standard_error": 697.4611538991269 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 205364.93312866107, + "upper_bound": 208054.89905753138 + }, + "point_estimate": 206633.65669456057, + "standard_error": 688.2855685246122 + } + ] + } + }, + "cache_read/active_patterns/64": { + "baseline_ns": 5238168.458999996, + "candidate_ns": 5254702.584000002, + "delta_percent": 0.3156470649888554, + "speedup": 0.9968534613071441, + "process_deltas_percent": [ + 0.3156470649888554, + 1.151555911770541, + 0.5758507615361452 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5219770.327675, + "upper_bound": 5259950.177699998 + }, + "point_estimate": 5238168.458999996, + "standard_error": 10290.884668342473 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5169313.211100003, + "upper_bound": 5225356.5712 + }, + "point_estimate": 5193951.452, + "standard_error": 14479.017829535991 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5209334.923524998, + "upper_bound": 5277602.488 + }, + "point_estimate": 5240064.443000001, + "standard_error": 17511.566811949775 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5216007.543675003, + "upper_bound": 5301324.354525001 + }, + "point_estimate": 5254702.584000002, + "standard_error": 21909.629981142087 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5213834.925, + "upper_bound": 5301419.1839000005 + }, + "point_estimate": 5253762.706999998, + "standard_error": 22420.143265853945 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 5237289.876625, + "upper_bound": 5307615.709200001 + }, + "point_estimate": 5270239.394000001, + "standard_error": 18002.435983221716 + } + ] + } + }, + "cache_write/active_patterns/1": { + "baseline_ns": 72396.57558441556, + "candidate_ns": 796.4641441250714, + "delta_percent": -98.8998593680769, + "speedup": 90.89746992181847, + "process_deltas_percent": [ + -98.92768771581058, + -98.88859897879732, + -98.87727568455111 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 72063.83955942029, + "upper_bound": 73345.06016304342 + }, + "point_estimate": 72619.6958405797, + "standard_error": 330.113077117266 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 71186.83314158345, + "upper_bound": 72201.75759236809 + }, + "point_estimate": 71663.07470756065, + "standard_error": 259.75718226701633 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 72042.38487409813, + "upper_bound": 72842.3469981962 + }, + "point_estimate": 72396.57558441556, + "standard_error": 206.08812939918425 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 775.7498273862833, + "upper_bound": 782.1914825398698 + }, + "point_estimate": 778.7099192395316, + "standard_error": 1.6508117243623281 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 793.3916170995846, + "upper_bound": 800.0948627106914 + }, + "point_estimate": 796.4641441250714, + "standard_error": 1.711476693547542 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 808.7875840192936, + "upper_bound": 817.1970366107597 + }, + "point_estimate": 812.8139576385619, + "standard_error": 2.1486087086627736 + } + ] + } + }, + "cache_write/active_patterns/16": { + "baseline_ns": 1178805.6611627908, + "candidate_ns": 12869.565432950192, + "delta_percent": -98.9082538490479, + "speedup": 91.59638429940085, + "process_deltas_percent": [ + -98.89435384101792, + -98.92300743091462, + -98.91603802229058 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1163520.6380872088, + "upper_bound": 1178998.2394418602 + }, + "point_estimate": 1170794.3272093027, + "standard_error": 3964.058587267085 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1170780.0541220931, + "upper_bound": 1188322.9692906977 + }, + "point_estimate": 1178805.6611627908, + "standard_error": 4480.856039473554 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1182105.4726309525, + "upper_bound": 1193223.6020178576 + }, + "point_estimate": 1187270.9280952378, + "standard_error": 2842.77750002634 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 12848.314476113823, + "upper_bound": 13058.465990020602 + }, + "point_estimate": 12944.842508369822, + "standard_error": 53.74175258227406 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 12634.501160732512, + "upper_bound": 12768.930516717715 + }, + "point_estimate": 12695.649374680957, + "standard_error": 34.34296347281535 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 12726.082891123879, + "upper_bound": 13069.182861430392 + }, + "point_estimate": 12869.565432950192, + "standard_error": 89.3945216724094 + } + ] + } + }, + "cache_write/active_patterns/17": { + "baseline_ns": 1249130.3737499998, + "candidate_ns": 34668.51831491713, + "delta_percent": -97.22458767767857, + "speedup": 36.030682430766745, + "process_deltas_percent": [ + -97.26642282382534, + -97.1808051276763, + -97.16166722147483 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1260199.4883937496, + "upper_bound": 1274279.5660125006 + }, + "point_estimate": 1266638.7442500005, + "standard_error": 3606.6936704734753 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1224290.6413475603, + "upper_bound": 1236151.2765548779 + }, + "point_estimate": 1229731.1780487804, + "standard_error": 3044.911558552088 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1243021.3964625006, + "upper_bound": 1256965.5133187498 + }, + "point_estimate": 1249130.3737499998, + "standard_error": 3583.8357921409856 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34459.075894164365, + "upper_bound": 34807.952293853596 + }, + "point_estimate": 34624.54761740332, + "standard_error": 89.14217654612706 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34422.35825448894, + "upper_bound": 34987.52880576656 + }, + "point_estimate": 34668.51831491713, + "standard_error": 145.76921604147267 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 34903.479212205275, + "upper_bound": 36129.948623092925 + }, + "point_estimate": 35454.47684466018, + "standard_error": 316.43507590820144 + } + ] + } + }, + "cache_write/active_patterns/64": { + "baseline_ns": 4926045.085, + "candidate_ns": 689333.2793150684, + "delta_percent": -86.00635464311695, + "speedup": 7.146100780009621, + "process_deltas_percent": [ + -86.21877251362046, + -85.93534527560652, + -86.00635464311695 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 4979237.028818182, + "upper_bound": 5078081.194386366 + }, + "point_estimate": 5025965.25818182, + "standard_error": 25342.14447496887 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 4854357.95934091, + "upper_bound": 4939986.497727273 + }, + "point_estimate": 4893782.671818182, + "standard_error": 21925.116188872562 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 4913201.529475001, + "upper_bound": 4940063.221974999 + }, + "point_estimate": 4926045.085, + "standard_error": 6859.056090837907 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 686740.2988835617, + "upper_bound": 699697.778160959 + }, + "point_estimate": 692639.7056164386, + "standard_error": 3318.574318587203 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 683269.8616130138, + "upper_bound": 694395.5643595892 + }, + "point_estimate": 688293.6357534251, + "standard_error": 2847.687158829965 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 684119.5085993151, + "upper_bound": 695601.4006095891 + }, + "point_estimate": 689333.2793150684, + "standard_error": 2940.0189931988843 + } + ] + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-0.txt new file mode 100644 index 0000000..cdf178f --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-0.txt @@ -0,0 +1,103 @@ +memcap: <=7736 MiB (60% of 12894 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0188 s (14k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [350.55 µs 351.85 µs 353.31 µs] + thrpt: [57.724 MiB/s 57.964 MiB/s 58.178 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.1529 s (500 iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [10.142 ms 10.166 ms 10.193 ms] + thrpt: [1.9660 MiB/s 1.9712 MiB/s 1.9759 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.1693 s (500 iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [10.196 ms 10.225 ms 10.257 ms] + thrpt: [1.9537 MiB/s 1.9599 MiB/s 1.9654 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 4 (4.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0063 s (18k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [279.72 µs 280.90 µs 282.20 µs] + thrpt: [83.796 MiB/s 84.184 MiB/s 84.538 MiB/s] +Found 5 outliers among 100 measurements (5.00%) + 2 (2.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0024 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [192.01 µs 192.78 µs 193.69 µs] + thrpt: [122.62 MiB/s 123.19 MiB/s 123.69 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0040 s (73k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [68.748 µs 69.108 µs 69.577 µs] + thrpt: [293.12 MiB/s 295.11 MiB/s 296.65 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 2 (2.00%) high mild + 8 (8.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.6695 s (600 iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [9.4513 ms 9.5130 ms 9.5851 ms] + thrpt: [2.0907 MiB/s 2.1065 MiB/s 2.1203 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 3 (3.00%) high mild + 9 (9.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.7616 s (600 iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [9.4440 ms 9.4710 ms 9.5060 ms] + thrpt: [2.1081 MiB/s 2.1159 MiB/s 2.1219 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0050 s (22k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [220.27 µs 222.77 µs 226.11 µs] + thrpt: [104.58 MiB/s 106.15 MiB/s 107.36 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 4 (4.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0046 s (102k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [48.524 µs 48.635 µs 48.769 µs] + thrpt: [486.97 MiB/s 488.32 MiB/s 489.44 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-1.txt new file mode 100644 index 0000000..2b04267 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-1.txt @@ -0,0 +1,103 @@ +memcap: <=7887 MiB (60% of 13146 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0221 s (14k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [352.07 µs 356.97 µs 363.43 µs] + thrpt: [56.116 MiB/s 57.132 MiB/s 57.928 MiB/s] +Found 18 outliers among 100 measurements (18.00%) + 7 (7.00%) high mild + 11 (11.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.1308 s (500 iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [10.230 ms 10.272 ms 10.323 ms] + thrpt: [1.9412 MiB/s 1.9509 MiB/s 1.9588 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.1707 s (500 iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [10.251 ms 10.279 ms 10.314 ms] + thrpt: [1.9430 MiB/s 1.9495 MiB/s 1.9549 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 9 (9.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0052 s (18k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [291.09 µs 298.09 µs 306.69 µs] + thrpt: [77.105 MiB/s 79.328 MiB/s 81.237 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 7 (7.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0014 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [191.66 µs 192.49 µs 193.50 µs] + thrpt: [122.73 MiB/s 123.38 MiB/s 123.91 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0057 s (72k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [68.822 µs 69.126 µs 69.603 µs] + thrpt: [293.01 MiB/s 295.03 MiB/s 296.33 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 3 (3.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.8066 s (600 iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [9.7182 ms 9.7973 ms 9.9045 ms] + thrpt: [2.0233 MiB/s 2.0454 MiB/s 2.0621 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 7 (7.00%) high mild + 5 (5.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.8097 s (600 iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [9.5971 ms 9.6221 ms 9.6496 ms] + thrpt: [2.0767 MiB/s 2.0827 MiB/s 2.0881 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0154 s (21k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [231.61 µs 232.46 µs 233.43 µs] + thrpt: [101.30 MiB/s 101.73 MiB/s 102.10 MiB/s] +Found 4 outliers among 100 measurements (4.00%) + 1 (1.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0009 s (102k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [48.406 µs 48.653 µs 48.955 µs] + thrpt: [485.12 MiB/s 488.14 MiB/s 490.62 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 4 (4.00%) high mild + 8 (8.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-2.txt new file mode 100644 index 0000000..820ca06 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-2.txt @@ -0,0 +1,103 @@ +memcap: <=7886 MiB (60% of 13144 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0279 s (14k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [350.12 µs 351.98 µs 354.52 µs] + thrpt: [57.526 MiB/s 57.942 MiB/s 58.249 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 3 (3.00%) high mild + 9 (9.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.0765 s (500 iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [10.112 ms 10.144 ms 10.179 ms] + thrpt: [1.9688 MiB/s 1.9756 MiB/s 1.9817 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.1387 s (500 iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [10.243 ms 10.317 ms 10.405 ms] + thrpt: [1.9259 MiB/s 1.9424 MiB/s 1.9564 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 6 (6.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0138 s (18k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [281.31 µs 282.41 µs 283.71 µs] + thrpt: [83.350 MiB/s 83.733 MiB/s 84.061 MiB/s] +Found 3 outliers among 100 measurements (3.00%) + 1 (1.00%) high mild + 2 (2.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0144 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [192.42 µs 192.91 µs 193.47 µs] + thrpt: [122.75 MiB/s 123.11 MiB/s 123.42 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 7 (7.00%) high mild + 5 (5.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0021 s (73k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [68.648 µs 68.934 µs 69.263 µs] + thrpt: [294.45 MiB/s 295.85 MiB/s 297.09 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 4 (4.00%) high mild + 8 (8.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.7129 s (600 iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [9.5280 ms 9.6032 ms 9.6897 ms] + thrpt: [2.0681 MiB/s 2.0868 MiB/s 2.1032 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.7491 s (600 iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [9.4742 ms 9.5573 ms 9.6694 ms] + thrpt: [2.0725 MiB/s 2.0968 MiB/s 2.1152 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0077 s (22k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [233.23 µs 237.28 µs 243.58 µs] + thrpt: [97.082 MiB/s 99.661 MiB/s 101.39 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0035 s (101k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [48.621 µs 48.778 µs 48.961 µs] + thrpt: [485.07 MiB/s 486.89 MiB/s 488.46 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-build.txt new file mode 100644 index 0000000..3270589 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline-build.txt @@ -0,0 +1,3 @@ +memcap: <=7803 MiB (60% of 13006 MiB available) [systemd MemoryMax, swap off] + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-baseline) + Finished `bench` profile [optimized] target(s) in 2.38s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/baseline.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-0.txt new file mode 100644 index 0000000..45881e6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-0.txt @@ -0,0 +1,103 @@ +memcap: <=7883 MiB (60% of 13139 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0105 s (25k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [195.40 µs 196.27 µs 197.21 µs] + thrpt: [103.42 MiB/s 103.91 MiB/s 104.37 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 8 (8.00%) high mild + 2 (2.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.0042 s (22k iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [227.93 µs 228.62 µs 229.52 µs] + thrpt: [87.311 MiB/s 87.654 MiB/s 87.918 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.0131 s (21k iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [242.34 µs 242.83 µs 243.42 µs] + thrpt: [82.324 MiB/s 82.525 MiB/s 82.693 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 4 (4.00%) high mild + 2 (2.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0016 s (19k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [267.27 µs 268.78 µs 270.67 µs] + thrpt: [87.367 MiB/s 87.981 MiB/s 88.478 MiB/s] +Found 3 outliers among 100 measurements (3.00%) + 2 (2.00%) high mild + 1 (1.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0001 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [191.73 µs 192.10 µs 192.52 µs] + thrpt: [123.36 MiB/s 123.63 MiB/s 123.87 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 7 (7.00%) high mild + 3 (3.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0017 s (94k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [52.665 µs 52.885 µs 53.184 µs] + thrpt: [383.47 MiB/s 385.63 MiB/s 387.25 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.0062 s (54k iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [92.712 µs 94.936 µs 97.927 µs] + thrpt: [204.64 MiB/s 211.09 MiB/s 216.15 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 5 (5.00%) high mild + 8 (8.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.0082 s (50k iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [101.14 µs 101.63 µs 102.19 µs] + thrpt: [196.10 MiB/s 197.18 MiB/s 198.14 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 5 (5.00%) high mild + 9 (9.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0000 s (26k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [190.69 µs 191.60 µs 192.68 µs] + thrpt: [122.73 MiB/s 123.42 MiB/s 124.01 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0014 s (135k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [37.003 µs 37.219 µs 37.491 µs] + thrpt: [633.47 MiB/s 638.09 MiB/s 641.83 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-1.txt new file mode 100644 index 0000000..dddf3da --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-1.txt @@ -0,0 +1,103 @@ +memcap: <=7888 MiB (60% of 13146 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0035 s (25k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [194.07 µs 194.64 µs 195.30 µs] + thrpt: [104.42 MiB/s 104.78 MiB/s 105.09 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.0045 s (22k iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [229.05 µs 230.53 µs 232.27 µs] + thrpt: [86.278 MiB/s 86.927 MiB/s 87.488 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 2 (2.00%) high mild + 9 (9.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.0163 s (20k iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [244.78 µs 246.34 µs 248.29 µs] + thrpt: [80.712 MiB/s 81.350 MiB/s 81.868 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 4 (4.00%) high mild + 10 (10.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0015 s (18k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [266.72 µs 267.98 µs 269.68 µs] + thrpt: [87.686 MiB/s 88.242 MiB/s 88.661 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 5 (5.00%) high mild + 3 (3.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0083 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [192.34 µs 193.03 µs 193.83 µs] + thrpt: [122.53 MiB/s 123.04 MiB/s 123.48 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0001 s (94k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [52.947 µs 53.182 µs 53.501 µs] + thrpt: [381.19 MiB/s 383.48 MiB/s 385.19 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.0062 s (54k iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [91.824 µs 92.221 µs 92.713 µs] + thrpt: [216.15 MiB/s 217.30 MiB/s 218.24 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.0013 s (47k iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [102.78 µs 103.45 µs 104.44 µs] + thrpt: [191.87 MiB/s 193.71 MiB/s 194.97 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0051 s (26k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [190.15 µs 190.79 µs 191.48 µs] + thrpt: [123.50 MiB/s 123.95 MiB/s 124.36 MiB/s] +Found 4 outliers among 100 measurements (4.00%) + 3 (3.00%) high mild + 1 (1.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0010 s (135k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [36.884 µs 37.052 µs 37.256 µs] + thrpt: [637.47 MiB/s 640.97 MiB/s 643.89 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-2.txt new file mode 100644 index 0000000..73296ef --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-2.txt @@ -0,0 +1,103 @@ +memcap: <=7886 MiB (60% of 13143 MiB available) [systemd MemoryMax, swap off] +Benchmarking constraint_read/enum/1000 +Benchmarking constraint_read/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_read/enum/1000: Collecting 100 samples in estimated 5.0173 s (26k iterations) +Benchmarking constraint_read/enum/1000: Analyzing +constraint_read/enum/1000 + time: [193.94 µs 194.92 µs 196.27 µs] + thrpt: [103.91 MiB/s 104.63 MiB/s 105.16 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_read/pattern/1000 +Benchmarking constraint_read/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_read/pattern/1000: Collecting 100 samples in estimated 5.0004 s (22k iterations) +Benchmarking constraint_read/pattern/1000: Analyzing +constraint_read/pattern/1000 + time: [228.56 µs 230.01 µs 232.01 µs] + thrpt: [86.375 MiB/s 87.125 MiB/s 87.676 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 3 (3.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_read/restricted/1000 +Benchmarking constraint_read/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_read/restricted/1000: Collecting 100 samples in estimated 5.0127 s (20k iterations) +Benchmarking constraint_read/restricted/1000: Analyzing +constraint_read/restricted/1000 + time: [242.98 µs 243.83 µs 244.77 µs] + thrpt: [81.869 MiB/s 82.185 MiB/s 82.474 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 4 (4.00%) high mild + 9 (9.00%) high severe +Benchmarking constraint_read/list/1000 +Benchmarking constraint_read/list/1000: Warming up for 3.0000 s +Benchmarking constraint_read/list/1000: Collecting 100 samples in estimated 5.0198 s (19k iterations) +Benchmarking constraint_read/list/1000: Analyzing +constraint_read/list/1000 + time: [267.05 µs 269.35 µs 273.08 µs] + thrpt: [86.596 MiB/s 87.793 MiB/s 88.550 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_read/content/1000 +Benchmarking constraint_read/content/1000: Warming up for 3.0000 s +Benchmarking constraint_read/content/1000: Collecting 100 samples in estimated 5.0146 s (26k iterations) +Benchmarking constraint_read/content/1000: Analyzing +constraint_read/content/1000 + time: [193.33 µs 194.91 µs 196.96 µs] + thrpt: [120.58 MiB/s 121.85 MiB/s 122.84 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 3 (3.00%) high mild + 10 (10.00%) high severe + +Benchmarking constraint_write/enum/1000 +Benchmarking constraint_write/enum/1000: Warming up for 3.0000 s +Benchmarking constraint_write/enum/1000: Collecting 100 samples in estimated 5.0001 s (94k iterations) +Benchmarking constraint_write/enum/1000: Analyzing +constraint_write/enum/1000 + time: [52.756 µs 53.574 µs 54.808 µs] + thrpt: [372.10 MiB/s 380.67 MiB/s 386.58 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking constraint_write/pattern/1000 +Benchmarking constraint_write/pattern/1000: Warming up for 3.0000 s +Benchmarking constraint_write/pattern/1000: Collecting 100 samples in estimated 5.0026 s (54k iterations) +Benchmarking constraint_write/pattern/1000: Analyzing +constraint_write/pattern/1000 + time: [91.809 µs 92.062 µs 92.361 µs] + thrpt: [216.97 MiB/s 217.67 MiB/s 218.27 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 3 (3.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_write/restricted/1000 +Benchmarking constraint_write/restricted/1000: Warming up for 3.0000 s +Benchmarking constraint_write/restricted/1000: Collecting 100 samples in estimated 5.0067 s (49k iterations) +Benchmarking constraint_write/restricted/1000: Analyzing +constraint_write/restricted/1000 + time: [102.39 µs 103.77 µs 105.42 µs] + thrpt: [190.09 MiB/s 193.12 MiB/s 195.72 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe +Benchmarking constraint_write/list/1000 +Benchmarking constraint_write/list/1000: Warming up for 3.0000 s +Benchmarking constraint_write/list/1000: Collecting 100 samples in estimated 5.0097 s (26k iterations) +Benchmarking constraint_write/list/1000: Analyzing +constraint_write/list/1000 + time: [190.98 µs 191.71 µs 192.55 µs] + thrpt: [122.81 MiB/s 123.35 MiB/s 123.82 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe +Benchmarking constraint_write/content/1000 +Benchmarking constraint_write/content/1000: Warming up for 3.0000 s +Benchmarking constraint_write/content/1000: Collecting 100 samples in estimated 5.0031 s (135k iterations) +Benchmarking constraint_write/content/1000: Analyzing +constraint_write/content/1000 + time: [37.221 µs 37.402 µs 37.607 µs] + thrpt: [631.52 MiB/s 634.98 MiB/s 638.07 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 5 (5.00%) high mild + 3 (3.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-build.txt new file mode 100644 index 0000000..192c3eb --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current-build.txt @@ -0,0 +1,3 @@ +memcap: <=7753 MiB (60% of 12922 MiB available) [systemd MemoryMax, swap off] + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-current) + Finished `bench` profile [optimized] target(s) in 2.37s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/current.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/harness.rs new file mode 100644 index 0000000..92b0c13 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/harness.rs @@ -0,0 +1,98 @@ +use criterion::{ + criterion_group, criterion_main, BenchmarkId, Criterion, SamplingMode, Throughput, +}; +use polyxml::ir::RestrictionFacets; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize, PolyValue}; +use std::{hint::black_box, sync::Arc}; + +fn fixture(kind: &str, count: usize) -> (Arc, Vec) { + let scalar = match kind { + "enum" => ScalarType::Enum((0..16).map(|i| format!("STATE{i}")).collect()), + "pattern" => ScalarType::Pattern( + Box::new(ScalarType::String), + vec!["[A-Z]{3}[0-9]{3}".into()], + ), + "restricted" => ScalarType::Restricted( + Box::new(ScalarType::String), + Box::new(RestrictionFacets { + patterns: vec!["[A-Z]{3}[0-9]{3}".into()], + length: Some(6), + ..Default::default() + }), + ), + "list" => ScalarType::List(Box::new(ScalarType::Int)), + "content" => ScalarType::String, + _ => unreachable!(), + }; + let mut builder = ModelSchema::builder("Root").field(FieldSchema::new( + "values", + b"Value", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Scalar(scalar))), + )); + if kind == "content" { + builder = builder + .content_pattern(polyxml::schema::compile_content_pattern("(?:Value;)*").unwrap()); + } + let schema = builder.build(); + let mut xml = String::from(""); + for i in 0..count { + let value = match kind { + "enum" => format!("STATE{}", i % 16), + "pattern" | "restricted" => format!("ABC{:03}", i % 1000), + "list" => format!("{i} {} -1", i + 1), + _ => format!("record-{i}"), + }; + xml.push_str(&format!("{value}")); + } + xml.push_str(""); + let value = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap(); + let values = value.get("values").unwrap().as_list().unwrap(); + assert_eq!(values.len(), count); + for (i, value) in values.iter().enumerate() { + match kind { + "enum" => assert_eq!(value.as_str(), Some(format!("STATE{}", i % 16).as_str())), + "pattern" | "restricted" => { + assert_eq!(value.as_str(), Some(format!("ABC{:03}", i % 1000).as_str())) + } + "list" => assert_eq!( + value, + &PolyValue::List(vec![ + PolyValue::Int(i as i64), + PolyValue::Int(i as i64 + 1), + PolyValue::Int(-1) + ]) + ), + _ => assert_eq!(value.as_str(), Some(format!("record-{i}").as_str())), + } + } + let output = serialize("Root", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml.into_bytes()) +} +fn benchmarks(c: &mut Criterion) { + for operation in ["constraint_read", "constraint_write"] { + let mut group = c.benchmark_group(operation); + group.sampling_mode(SamplingMode::Flat); + for kind in ["enum", "pattern", "restricted", "list", "content"] { + let (schema, xml) = fixture(kind, 1000); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_function(BenchmarkId::new(kind, 1000), |b| { + if operation == "constraint_read" { + b.iter(|| { + black_box(deserialize(black_box(&xml), Arc::clone(&schema)).unwrap()) + }); + } else { + b.iter(|| { + black_box(serialize("Root", black_box(&value), &schema, None).unwrap()) + }); + } + }); + } + group.finish(); + } +} +criterion_group!(benches, benchmarks); +criterion_main!(benches); diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/metadata.json new file mode 100644 index 0000000..30a54e6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/metadata.json @@ -0,0 +1,19 @@ +{ + "revisions": { + "baseline": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "current": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d" + }, + "core_status": { + "baseline": "", + "current": "" + }, + "sample_size": 100, + "warmup_seconds": 3.0, + "measurement_seconds": 5.0, + "rounds": 3, + "filter": "", + "order": "alternate baseline/current per round", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "cpu": "11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/samples.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/samples.tar.gz new file mode 100644 index 0000000..680d193 Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/samples.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/summary.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/summary.json new file mode 100644 index 0000000..c743f65 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-constraints/summary.json @@ -0,0 +1,712 @@ +{ + "constraint_read/content/1000": { + "baseline_ns": 192784.15205426357, + "candidate_ns": 193025.3596875, + "delta_percent": 0.12511797814611647, + "speedup": 0.9987503837131715, + "process_deltas_percent": [ + -0.3556982090925809, + 0.2755387924475938, + 1.0358564732894981 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 192011.47114922488, + "upper_bound": 193690.13464437993 + }, + "point_estimate": 192784.15205426357, + "standard_error": 429.961938727426 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 191663.15066085276, + "upper_bound": 193501.35719961242 + }, + "point_estimate": 192494.96139534877, + "standard_error": 470.1195098363425 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 192420.04543190668, + "upper_bound": 193470.14142704284 + }, + "point_estimate": 192910.69249027234, + "standard_error": 269.3503261614119 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 191728.831957529, + "upper_bound": 192515.09873841706 + }, + "point_estimate": 192098.42227799224, + "standard_error": 200.6790523442683 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 192337.85522070312, + "upper_bound": 193830.82442089845 + }, + "point_estimate": 193025.3596875, + "standard_error": 380.6987096060202 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 193333.53452220085, + "upper_bound": 196964.945715251 + }, + "point_estimate": 194908.9703861004, + "standard_error": 939.046062603845 + } + ] + } + }, + "constraint_read/enum/1000": { + "baseline_ns": 351978.5340714285, + "candidate_ns": 194919.055703125, + "delta_percent": -44.6218911567007, + "speedup": 1.805767695732714, + "process_deltas_percent": [ + -44.21725494287344, + -45.473257800854185, + -44.6218911567007 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 350550.511975352, + "upper_bound": 353306.45720246487 + }, + "point_estimate": 351846.80852112663, + "standard_error": 703.2671500408054 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 352065.6845950706, + "upper_bound": 363429.09119718306 + }, + "point_estimate": 356968.63415492955, + "standard_error": 2920.4875416446152 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 350123.51167678577, + "upper_bound": 354521.87073571427 + }, + "point_estimate": 351978.5340714285, + "standard_error": 1140.7750724277478 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 195404.80860236226, + "upper_bound": 197206.3291043307 + }, + "point_estimate": 196269.8081889763, + "standard_error": 459.18322771458924 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 194070.0746699605, + "upper_bound": 195304.9188774704 + }, + "point_estimate": 194643.3668774704, + "standard_error": 316.2353254878659 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 193941.41461621094, + "upper_bound": 196268.41965234376 + }, + "point_estimate": 194919.055703125, + "standard_error": 603.4608105845159 + } + ] + } + }, + "constraint_read/list/1000": { + "baseline_ns": 282412.5136871508, + "candidate_ns": 268777.48951612896, + "delta_percent": -4.828052409223749, + "speedup": 1.0507297846838606, + "process_deltas_percent": [ + -4.315803850402666, + -10.10115823763339, + -4.623796423950866 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 279724.9669928978, + "upper_bound": 282199.2758352274 + }, + "point_estimate": 280900.60880681814, + "standard_error": 631.7159788317759 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 291091.6212286931, + "upper_bound": 306690.0491122158 + }, + "point_estimate": 298094.52153409086, + "standard_error": 4013.9514461347862 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 281311.55979469273, + "upper_bound": 283711.85325977637 + }, + "point_estimate": 282412.5136871508, + "standard_error": 615.8407858633855 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 267268.3925456989, + "upper_bound": 270665.38852956996 + }, + "point_estimate": 268777.48951612896, + "standard_error": 868.6841123701857 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 266716.7653337839, + "upper_bound": 269680.6977324324 + }, + "point_estimate": 267983.5222162162, + "standard_error": 763.4517783543566 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 267050.2594139786, + "upper_bound": 273077.0408870968 + }, + "point_estimate": 269354.3339784946, + "standard_error": 1631.8889530253089 + } + ] + } + }, + "constraint_read/pattern/1000": { + "baseline_ns": 10165972.410000002, + "candidate_ns": 230008.7672811059, + "delta_percent": -97.73746417947335, + "speedup": 44.19819526955522, + "process_deltas_percent": [ + -97.75111812666964, + -97.75568272245698, + -97.7325047421401 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10141748.657949999, + "upper_bound": 10193074.248800002 + }, + "point_estimate": 10165972.410000002, + "standard_error": 13149.645414607558 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10230447.092900004, + "upper_bound": 10323129.420400003 + }, + "point_estimate": 10271818.862, + "standard_error": 23888.554917080884 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10112120.2727, + "upper_bound": 10178805.768599998 + }, + "point_estimate": 10143737.521999996, + "standard_error": 17007.00632616697 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 227934.89719178076, + "upper_bound": 229520.11902739733 + }, + "point_estimate": 228620.71077625564, + "standard_error": 409.11904790238225 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 229054.34856105977, + "upper_bound": 232267.8773536866 + }, + "point_estimate": 230532.20543778807, + "standard_error": 823.6387146109047 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 228562.77638248855, + "upper_bound": 232007.16450115215 + }, + "point_estimate": 230008.7672811059, + "standard_error": 894.4887261618319 + } + ] + } + }, + "constraint_read/restricted/1000": { + "baseline_ns": 10279245.064, + "candidate_ns": 243833.60565853666, + "delta_percent": -97.62790356548176, + "speedup": 42.15680212019258, + "process_deltas_percent": [ + -97.62509847502601, + -97.60353199729835, + -97.63657490177884 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10195968.201049998, + "upper_bound": 10257092.893349996 + }, + "point_estimate": 10224827.685999995, + "standard_error": 15643.48242136762 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10250724.5489, + "upper_bound": 10313707.164000003 + }, + "point_estimate": 10279245.064, + "standard_error": 16180.30230027165 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 10243154.13675, + "upper_bound": 10405363.819749998 + }, + "point_estimate": 10316959.307999996, + "standard_error": 41546.65486789841 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 242335.7666917476, + "upper_bound": 243423.11083131062 + }, + "point_estimate": 242829.5886407767, + "standard_error": 277.6900711383286 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 244778.24533414625, + "upper_bound": 248285.3462121951 + }, + "point_estimate": 246338.8188780486, + "standard_error": 901.7468871209679 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 242979.6416841465, + "upper_bound": 244774.59950853663 + }, + "point_estimate": 243833.60565853666, + "standard_error": 459.0387312247824 + } + ] + } + }, + "constraint_write/content/1000": { + "baseline_ns": 48652.90011764704, + "candidate_ns": 37219.495173945215, + "delta_percent": -23.499945359998755, + "speedup": 1.307188608826311, + "process_deltas_percent": [ + -23.471029676822585, + -23.843474987272927, + -23.322316539897535 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 48523.848510039206, + "upper_bound": 48769.40897257592 + }, + "point_estimate": 48634.51712047012, + "standard_error": 63.03099978701998 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 48406.46254289218, + "upper_bound": 48955.31484485293 + }, + "point_estimate": 48652.90011764704, + "standard_error": 141.00254748735813 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 48620.898187438186, + "upper_bound": 48960.625864243324 + }, + "point_estimate": 48777.92458951531, + "standard_error": 87.04739079917228 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 37002.76390377497, + "upper_bound": 37491.108981680234 + }, + "point_estimate": 37219.495173945215, + "standard_error": 125.80220737947377 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 36884.13980753524, + "upper_bound": 37255.50575092797 + }, + "point_estimate": 37052.358047512986, + "standard_error": 95.19461631667714 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 37220.737900817236, + "upper_bound": 37606.885702080246 + }, + "point_estimate": 37401.78261515603, + "standard_error": 98.95960702051671 + } + ] + } + }, + "constraint_write/enum/1000": { + "baseline_ns": 69107.85810439564, + "candidate_ns": 53181.97295116775, + "delta_percent": -23.044969978913166, + "speedup": 1.2994602168642972, + "process_deltas_percent": [ + -23.474002980167608, + -23.06544890499511, + -22.281722343628196 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 68748.3373385989, + "upper_bound": 69577.05103708793 + }, + "point_estimate": 69107.85810439564, + "standard_error": 214.0495325958438 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 68822.09968428375, + "upper_bound": 69603.15337726008 + }, + "point_estimate": 69126.25367176632, + "standard_error": 207.6133072545296 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 68647.59167906336, + "upper_bound": 69263.02710743803 + }, + "point_estimate": 68933.88318181818, + "standard_error": 157.729643166622 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 52664.844984824274, + "upper_bound": 53183.825820021295 + }, + "point_estimate": 52885.4774334398, + "standard_error": 133.91920778421817 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 52946.81040366241, + "upper_bound": 53501.033257165596 + }, + "point_estimate": 53181.97295116775, + "standard_error": 143.54169957289216 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 52755.5215380724, + "upper_bound": 54808.05200372738 + }, + "point_estimate": 53574.22673056444, + "standard_error": 542.8918021806168 + } + ] + } + }, + "constraint_write/list/1000": { + "baseline_ns": 232458.26257009353, + "candidate_ns": 191602.29132575757, + "delta_percent": -17.57561585147639, + "speedup": 1.213233208025021, + "process_deltas_percent": [ + -13.991713070968636, + -17.92600836313144, + -19.204531360684506 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 220267.68714351847, + "upper_bound": 226110.526582176 + }, + "point_estimate": 222771.89578703707, + "standard_error": 1516.6126964134764 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 231608.84587266337, + "upper_bound": 233427.2197324767 + }, + "point_estimate": 232458.26257009353, + "standard_error": 463.83703181049367 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 233233.74181162787, + "upper_bound": 243579.52593488392 + }, + "point_estimate": 237276.4200465117, + "standard_error": 2741.4506043360634 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 190686.22409564396, + "upper_bound": 192684.6898219697 + }, + "point_estimate": 191602.29132575757, + "standard_error": 510.5381288029201 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 190151.26949904938, + "upper_bound": 191480.99621577948 + }, + "point_estimate": 190787.77498098853, + "standard_error": 339.87984564104255 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 190979.97200471684, + "upper_bound": 192552.80349433955 + }, + "point_estimate": 191708.59554716985, + "standard_error": 403.1152679872416 + } + ] + } + }, + "constraint_write/pattern/1000": { + "baseline_ns": 9603202.148333333, + "candidate_ns": 92220.86494464944, + "delta_percent": -99.0396863096269, + "speedup": 104.1326402012943, + "process_deltas_percent": [ + -99.00204290931394, + -99.0587072021266, + -99.04133622823704 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9451347.930458333, + "upper_bound": 9585143.830125 + }, + "point_estimate": 9513021.858333332, + "standard_error": 34258.357194274584 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9718157.326208336, + "upper_bound": 9904496.882541668 + }, + "point_estimate": 9797255.98166666, + "standard_error": 48148.50860444387 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9527952.328458337, + "upper_bound": 9689721.79883333 + }, + "point_estimate": 9603202.148333333, + "standard_error": 41353.86454159899 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 92712.16177125697, + "upper_bound": 97926.8694385397 + }, + "point_estimate": 94935.87617375235, + "standard_error": 1351.4178106433126 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 91824.3200193727, + "upper_bound": 92713.13078228779 + }, + "point_estimate": 92220.86494464944, + "standard_error": 229.45224577482114 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 91809.24058271032, + "upper_bound": 92360.91219672895 + }, + "point_estimate": 92062.41992523367, + "standard_error": 141.7752341310761 + } + ] + } + }, + "constraint_write/restricted/1000": { + "baseline_ns": 9557318.668333333, + "candidate_ns": 103450.17048936168, + "delta_percent": -98.91758165569881, + "speedup": 92.38572177429289, + "process_deltas_percent": [ + -98.92695475051941, + -98.92486400018623, + -98.91425610002929 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9443962.078624997, + "upper_bound": 9506008.997624997 + }, + "point_estimate": 9471042.083333332, + "standard_error": 15924.625444093057 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9597078.327791667, + "upper_bound": 9649585.701416671 + }, + "point_estimate": 9622054.373333333, + "standard_error": 13430.221780022812 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 9474193.988166666, + "upper_bound": 9669412.452041669 + }, + "point_estimate": 9557318.668333333, + "standard_error": 50444.16554886872 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 101140.82658888891, + "upper_bound": 102189.1773075758 + }, + "point_estimate": 101628.56715151516, + "standard_error": 267.938288281019 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 102780.65178936171, + "upper_bound": 104440.732693617 + }, + "point_estimate": 103450.17048936168, + "standard_error": 433.88242535341345 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 102388.3408230223, + "upper_bound": 105422.43375000003 + }, + "point_estimate": 103768.00444219066, + "standard_error": 776.2119541271966 + } + ] + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-0.txt new file mode 100644 index 0000000..ac0adea --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-0.txt @@ -0,0 +1,63 @@ +memcap: <=7712 MiB (60% of 12854 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0023 s (4.8M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0397 µs 1.0438 µs 1.0487 µs] + thrpt: [85.478 MiB/s 85.880 MiB/s 86.224 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 8.1109 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [800.95 µs 809.87 µs 820.95 µs] + thrpt: [74.243 MiB/s 75.259 MiB/s 76.097 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.6895 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.9707 ms 8.0125 ms 8.0717 ms] + thrpt: [79.032 MiB/s 79.616 MiB/s 80.034 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0012 s (18M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [277.86 ns 278.64 ns 279.67 ns] + thrpt: [320.54 MiB/s 321.72 MiB/s 322.63 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 6 (6.00%) high mild + 3 (3.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.6112 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [221.19 µs 222.19 µs 223.37 µs] + thrpt: [270.73 MiB/s 272.17 MiB/s 273.40 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.0121 s (2200 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [2.2436 ms 2.2557 ms 2.2700 ms] + thrpt: [278.92 MiB/s 280.69 MiB/s 282.20 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-1.txt new file mode 100644 index 0000000..f361ff6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-1.txt @@ -0,0 +1,63 @@ +memcap: <=7799 MiB (60% of 12998 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0037 s (4.7M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0418 µs 1.0489 µs 1.0580 µs] + thrpt: [84.730 MiB/s 85.467 MiB/s 86.048 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 8.0372 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [795.52 µs 798.95 µs 803.13 µs] + thrpt: [75.891 MiB/s 76.288 MiB/s 76.617 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 6 (6.00%) high mild + 5 (5.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.6229 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.9206 ms 7.9408 ms 7.9631 ms] + thrpt: [80.110 MiB/s 80.335 MiB/s 80.540 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0000 s (18M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [279.13 ns 280.57 ns 282.39 ns] + thrpt: [317.45 MiB/s 319.51 MiB/s 321.17 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 2 (2.00%) high mild + 9 (9.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.5997 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [221.00 µs 222.48 µs 224.63 µs] + thrpt: [269.21 MiB/s 271.82 MiB/s 273.64 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 2 (2.00%) high mild + 9 (9.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.0150 s (2200 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [2.2343 ms 2.2532 ms 2.2801 ms] + thrpt: [277.69 MiB/s 281.00 MiB/s 283.38 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-2.txt new file mode 100644 index 0000000..7898391 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-2.txt @@ -0,0 +1,64 @@ +memcap: <=7803 MiB (60% of 13006 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0002 s (4.5M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0398 µs 1.0439 µs 1.0499 µs] + thrpt: [85.385 MiB/s 85.875 MiB/s 86.214 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 6 (6.00%) high mild + 5 (5.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 8.1008 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [793.60 µs 796.31 µs 799.29 µs] + thrpt: [76.256 MiB/s 76.541 MiB/s 76.802 MiB/s] +Found 4 outliers among 100 measurements (4.00%) + 3 (3.00%) high mild + 1 (1.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.6160 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.9615 ms 8.0115 ms 8.0717 ms] + thrpt: [79.032 MiB/s 79.626 MiB/s 80.126 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0008 s (18M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [277.96 ns 278.74 ns 279.72 ns] + thrpt: [320.48 MiB/s 321.60 MiB/s 322.51 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 1 (1.00%) low mild + 5 (5.00%) high mild + 3 (3.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.6002 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [221.15 µs 223.78 µs 227.58 µs] + thrpt: [265.73 MiB/s 270.23 MiB/s 273.45 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.2011 s (2300 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [2.2336 ms 2.2408 ms 2.2494 ms] + thrpt: [281.48 MiB/s 282.55 MiB/s 283.47 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 8 (8.00%) high mild + 4 (4.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-build.txt new file mode 100644 index 0000000..70e0ce1 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline-build.txt @@ -0,0 +1,3 @@ +memcap: <=7606 MiB (60% of 12678 MiB available) [systemd MemoryMax, swap off] + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-baseline) + Finished `bench` profile [optimized] target(s) in 2.58s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/baseline.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-0.txt new file mode 100644 index 0000000..acb2db4 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-0.txt @@ -0,0 +1,64 @@ +memcap: <=7782 MiB (60% of 12971 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0026 s (5.0M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0248 µs 1.0384 µs 1.0553 µs] + thrpt: [84.948 MiB/s 86.327 MiB/s 87.480 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 7 (7.00%) high mild + 5 (5.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.9777 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [783.17 µs 785.61 µs 788.56 µs] + thrpt: [77.293 MiB/s 77.583 MiB/s 77.825 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5413 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.8378 ms 7.8695 ms 7.9092 ms] + thrpt: [80.656 MiB/s 81.063 MiB/s 81.390 MiB/s] +Found 3 outliers among 100 measurements (3.00%) + 3 (3.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0004 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [226.75 ns 227.46 ns 228.32 ns] + thrpt: [392.63 MiB/s 394.12 MiB/s 395.34 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.4073 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [178.35 µs 179.74 µs 181.57 µs] + thrpt: [333.07 MiB/s 336.46 MiB/s 339.07 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.2s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.2071 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.7955 ms 1.8067 ms 1.8201 ms] + thrpt: [347.87 MiB/s 350.45 MiB/s 352.63 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 6 (6.00%) high mild + 5 (5.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-1.txt new file mode 100644 index 0000000..e6cd8d7 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-1.txt @@ -0,0 +1,65 @@ +memcap: <=7795 MiB (60% of 12992 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0030 s (4.9M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0024 µs 1.0062 µs 1.0107 µs] + thrpt: [88.693 MiB/s 89.096 MiB/s 89.428 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.8958 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [780.50 µs 783.58 µs 787.04 µs] + thrpt: [77.442 MiB/s 77.785 MiB/s 78.091 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5023 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.8955 ms 7.9463 ms 8.0029 ms] + thrpt: [79.711 MiB/s 80.279 MiB/s 80.796 MiB/s] +Found 16 outliers among 100 measurements (16.00%) + 6 (6.00%) high mild + 10 (10.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0010 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [226.75 ns 227.72 ns 228.94 ns] + thrpt: [391.56 MiB/s 393.67 MiB/s 395.35 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 4 (4.00%) high mild + 6 (6.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.3973 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [177.52 µs 179.83 µs 183.65 µs] + thrpt: [329.29 MiB/s 336.28 MiB/s 340.65 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.1s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.0671 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.7927 ms 1.7997 ms 1.8086 ms] + thrpt: [350.07 MiB/s 351.82 MiB/s 353.19 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 10 (10.00%) high mild + 3 (3.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-2.txt new file mode 100644 index 0000000..a3f0e00 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-2.txt @@ -0,0 +1,65 @@ +memcap: <=7805 MiB (60% of 13009 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0028 s (5.0M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0073 µs 1.0135 µs 1.0215 µs] + thrpt: [87.759 MiB/s 88.448 MiB/s 88.992 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 7 (7.00%) high mild + 6 (6.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.9062 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [783.97 µs 791.07 µs 802.60 µs] + thrpt: [75.941 MiB/s 77.048 MiB/s 77.746 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5341 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.9004 ms 7.9325 ms 7.9721 ms] + thrpt: [80.019 MiB/s 80.418 MiB/s 80.746 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0005 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [226.79 ns 227.53 ns 228.55 ns] + thrpt: [392.23 MiB/s 394.00 MiB/s 395.29 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.4104 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [178.32 µs 180.09 µs 183.03 µs] + thrpt: [330.40 MiB/s 335.80 MiB/s 339.14 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 4 (4.00%) high mild + 4 (4.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.1s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.1209 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.7935 ms 1.8057 ms 1.8226 ms] + thrpt: [347.39 MiB/s 350.63 MiB/s 353.03 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 5 (5.00%) high mild + 5 (5.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-build.txt new file mode 100644 index 0000000..450f377 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current-build.txt @@ -0,0 +1,4 @@ +memcap: <=7578 MiB (60% of 12631 MiB available) [systemd MemoryMax, swap off] + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-current) + Finished `bench` profile [optimized] target(s) in 26.30s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/current.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/harness.rs new file mode 100644 index 0000000..073ad98 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/harness.rs @@ -0,0 +1,172 @@ +use std::hint::black_box; + +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput}; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let output = serialize("Sensor", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + let xml = xml.into_bytes(); + let value = deserialize(&xml, Arc::clone(&catalog_schema)).unwrap(); + assert_eq!(value.get("items").unwrap().as_list().unwrap().len(), count); + let output = serialize("Catalog", &value, &catalog_schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&catalog_schema)).unwrap()); + (catalog_schema, xml) +} + +fn bench_deserialization(c: &mut Criterion) { + let mut group = c.benchmark_group("deserialization"); + + // 1. Sensor Telemetry (Micro) + { + let (schema, xml) = build_sensor_fixture(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_function("sensor_micro", |b| { + b.iter(|| { + let res = deserialize(black_box(&xml), Arc::clone(&schema)).unwrap(); + black_box(res); + }); + }); + } + + // 2. Catalog Batch (1,000 and 10,000 items) + for &count in &[1_000, 10_000] { + let (schema, xml) = build_catalog_fixture(count); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_with_input(BenchmarkId::new("catalog_items", count), &count, |b, _| { + b.iter(|| { + let res = deserialize(black_box(&xml), Arc::clone(&schema)).unwrap(); + black_box(res); + }); + }); + } + + group.finish(); +} + +fn bench_serialization(c: &mut Criterion) { + let mut group = c.benchmark_group("serialization"); + + // 1. Sensor Telemetry (Micro) + { + let (schema, xml) = build_sensor_fixture(); + let val = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let expected_bytes = serialize("Sensor", &val, &schema, None).unwrap(); + group.throughput(Throughput::Bytes(expected_bytes.len() as u64)); + group.bench_function("sensor_micro", |b| { + b.iter(|| { + let res = serialize( + black_box("Sensor"), + black_box(&val), + black_box(&schema), + black_box(None), + ) + .unwrap(); + black_box(res); + }); + }); + } + + // 2. Catalog Batch (1,000 and 10,000 items) + for &count in &[1_000, 10_000] { + let (schema, xml) = build_catalog_fixture(count); + let val = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let expected_bytes = serialize("Catalog", &val, &schema, None).unwrap(); + group.throughput(Throughput::Bytes(expected_bytes.len() as u64)); + group.bench_with_input(BenchmarkId::new("catalog_items", count), &count, |b, _| { + b.iter(|| { + let res = serialize( + black_box("Catalog"), + black_box(&val), + black_box(&schema), + black_box(None), + ) + .unwrap(); + black_box(res); + }); + }); + } + + group.finish(); +} + +criterion_group!(benches, bench_deserialization, bench_serialization); +criterion_main!(benches); diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/metadata.json new file mode 100644 index 0000000..30a54e6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/metadata.json @@ -0,0 +1,19 @@ +{ + "revisions": { + "baseline": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "current": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d" + }, + "core_status": { + "baseline": "", + "current": "" + }, + "sample_size": 100, + "warmup_seconds": 3.0, + "measurement_seconds": 5.0, + "rounds": 3, + "filter": "", + "order": "alternate baseline/current per round", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "cpu": "11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/samples.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/samples.tar.gz new file mode 100644 index 0000000..41bd561 Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/samples.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/summary.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/summary.json new file mode 100644 index 0000000..94f4e12 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-core/summary.json @@ -0,0 +1,428 @@ +{ + "deserialization/catalog_items/1000": { + "baseline_ns": 797833.5261393462, + "candidate_ns": 788424.9660875333, + "delta_percent": -1.1792635610764823, + "speedup": 1.0119333613932875, + "process_deltas_percent": [ + -1.8958643759295013, + -1.915982610929079, + -0.8826788224081006 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 799532.2112831267, + "upper_bound": 809219.6958180026 + }, + "point_estimate": 803838.501714823, + "standard_error": 2476.580723266154 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 794986.232183415, + "upper_bound": 801113.8410416687 + }, + "point_estimate": 797833.5261393462, + "standard_error": 1570.2268761288622 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 793451.9379436309, + "upper_bound": 797611.8312974452 + }, + "point_estimate": 795446.2012496133, + "standard_error": 1061.7779549556037 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 784985.9953746912, + "upper_bound": 793757.3760705153 + }, + "point_estimate": 788598.8139208062, + "standard_error": 2265.2943721688466 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 780335.0081865456, + "upper_bound": 785021.9580782912 + }, + "point_estimate": 782547.174514354, + "standard_error": 1198.7289358492235 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 783448.4665583959, + "upper_bound": 796282.4779193875 + }, + "point_estimate": 788424.9660875333, + "standard_error": 3411.2556309273987 + } + ] + } + }, + "deserialization/catalog_items/10000": { + "baseline_ns": 8011487.355714288, + "candidate_ns": 7932545.304285713, + "delta_percent": -0.9853607441852708, + "speedup": 1.0099516672644686, + "process_deltas_percent": [ + -1.7850624621618572, + 0.06954510463470509, + -0.9853607441852708 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7970668.087, + "upper_bound": 8071697.069357144 + }, + "point_estimate": 8012485.927142858, + "standard_error": 26214.62004763146 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7920554.717499999, + "upper_bound": 7963097.797785714 + }, + "point_estimate": 7940813.622857141, + "standard_error": 10881.05129260154 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7961532.670214283, + "upper_bound": 8071744.1166071445 + }, + "point_estimate": 8011487.355714288, + "standard_error": 28316.961345854943 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7837819.287178568, + "upper_bound": 7909175.841678573 + }, + "point_estimate": 7869458.048571429, + "standard_error": 18310.097440139038 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7895514.731214287, + "upper_bound": 8002912.73882143 + }, + "point_estimate": 7946336.070000004, + "standard_error": 27484.300947893757 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7900379.659571433, + "upper_bound": 7972142.8773928555 + }, + "point_estimate": 7932545.304285713, + "standard_error": 18376.772936613295 + } + ] + } + }, + "deserialization/sensor_micro": { + "baseline_ns": 1045.5200973076508, + "candidate_ns": 1012.4512243320339, + "delta_percent": -3.162911268829116, + "speedup": 1.0326621887364837, + "process_deltas_percent": [ + 0.6360138719433861, + -3.6361593320438756, + -3.0481321180644394 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1042.2244239090974, + "upper_bound": 1049.2327585328444 + }, + "point_estimate": 1045.5200973076508, + "standard_error": 1.7914181315589672 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1041.8635732657767, + "upper_bound": 1051.1210011528785 + }, + "point_estimate": 1046.1331252294583, + "standard_error": 2.366374231237247 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1040.2154800712067, + "upper_bound": 1049.156988961515 + }, + "point_estimate": 1044.2823294183047, + "standard_error": 2.2945678507867733 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1034.6355672632849, + "upper_bound": 1072.3183253610553 + }, + "point_estimate": 1052.1697501604833, + "standard_error": 9.669741916074136 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1003.2493302554437, + "upper_bound": 1015.1392332567225 + }, + "point_estimate": 1008.0940579708251, + "standard_error": 3.10622950276016 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1006.1180021959498, + "upper_bound": 1020.8507199364512 + }, + "point_estimate": 1012.4512243320339, + "standard_error": 3.790183737338208 + } + ] + } + }, + "serialization/catalog_items/1000": { + "baseline_ns": 223145.9882051632, + "candidate_ns": 179230.66994650094, + "delta_percent": -19.680084151136946, + "speedup": 1.2450212247254928, + "process_deltas_percent": [ + -18.837194374512833, + -20.138787201636166, + -19.680084151136946 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 220934.08695139113, + "upper_bound": 222498.76062169587 + }, + "point_estimate": 221649.37333736618, + "standard_error": 399.9496419105096 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 221612.6086923217, + "upper_bound": 226317.661526089 + }, + "point_estimate": 223660.78501171924, + "standard_error": 1214.3079796797558 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 220910.10177913276, + "upper_bound": 226272.28547549626 + }, + "point_estimate": 223145.9882051632, + "standard_error": 1399.113038331349 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 178605.65686876696, + "upper_bound": 181506.66091107114 + }, + "point_estimate": 179896.8500519169, + "standard_error": 747.5788153567596 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 177485.862067036, + "upper_bound": 180300.7592748305 + }, + "point_estimate": 178618.21546470016, + "standard_error": 737.3029682330406 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 178333.7570355378, + "upper_bound": 180432.92574326537 + }, + "point_estimate": 179230.66994650094, + "standard_error": 541.368200099929 + } + ] + } + }, + "serialization/catalog_items/10000": { + "baseline_ns": 2253218.7295454564, + "candidate_ns": 1800462.8142351345, + "delta_percent": -20.093740096047252, + "speedup": 1.251466407265212, + "process_deltas_percent": [ + -19.76108299861896, + -20.143063994644915, + -19.652219491071488 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2243601.8854659093, + "upper_bound": 2270008.0116250003 + }, + "point_estimate": 2255711.208636365, + "standard_error": 6769.357974082321 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2234262.100818181, + "upper_bound": 2280051.4055340905 + }, + "point_estimate": 2253218.7295454564, + "standard_error": 11941.068058055207 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2233575.333847826, + "upper_bound": 2249410.388641304 + }, + "point_estimate": 2240837.0247826087, + "standard_error": 4056.0375502345505 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1794313.1049709097, + "upper_bound": 1834035.225392686 + }, + "point_estimate": 1809958.244488582, + "standard_error": 10460.240859219453 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1792772.361440959, + "upper_bound": 1806869.3060514675 + }, + "point_estimate": 1799351.43891379, + "standard_error": 3615.653029781425 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1791409.8688864545, + "upper_bound": 1814316.5045500542 + }, + "point_estimate": 1800462.8142351345, + "standard_error": 6019.913136680816 + } + ] + } + }, + "serialization/sensor_micro": { + "baseline_ns": 279.4411250820028, + "candidate_ns": 227.97099841316538, + "delta_percent": -18.418951989881016, + "speedup": 1.2257748881529005, + "process_deltas_percent": [ + -18.32936781668503, + -18.506224118816974, + -17.910494436765966 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 278.2007834595497, + "upper_bound": 279.89724946085283 + }, + "point_estimate": 278.96854995222077, + "standard_error": 0.43506063609240686 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 278.8114209442464, + "upper_bound": 280.80762945251865 + }, + "point_estimate": 279.7403801065058, + "standard_error": 0.5102088544660345 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 277.8007662524021, + "upper_bound": 282.20571822088056 + }, + "point_estimate": 279.4411250820028, + "standard_error": 1.230938186474223 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 226.85031956310297, + "upper_bound": 229.04721627712746 + }, + "point_estimate": 227.83537833860552, + "standard_error": 0.56438527532655 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 226.69462761041316, + "upper_bound": 229.9228664115092 + }, + "point_estimate": 227.97099841316538, + "standard_error": 0.8469481344974963 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 227.41731968847313, + "upper_bound": 232.51148323005495 + }, + "point_estimate": 229.39183792015447, + "standard_error": 1.3466850428894233 + } + ] + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-0.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-0.csv new file mode 100644 index 0000000..9d198dc --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-0.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,826600,302.478,65 +xml_read,1,1,831100,300.833,65 +xml_read,1,2,838400,298.212,65 +xml_read,1,3,837800,298.424,65 +xml_read,1,4,811600,308.044,65 +xml_read,1,5,832300,300.385,65 +xml_read,1,6,837500,298.518,65 +xml_write,1,0,1469700,170.107,65 +xml_write,1,1,1445300,172.982,65 +xml_write,1,2,1459900,171.250,65 +xml_write,1,3,1476200,169.360,65 +xml_write,1,4,1465600,170.590,65 +xml_write,1,5,1477300,169.256,65 +xml_write,1,6,1463100,170.871,65 +json_read,1,0,3108200,80.435,40 +json_read,1,1,2991900,83.562,40 +json_read,1,2,3064800,81.574,40 +json_read,1,3,3034500,82.388,40 +json_read,1,4,3036600,82.331,40 +json_read,1,5,3034200,82.395,40 +json_read,1,6,3000900,83.309,40 +json_write,1,0,6324500,39.529,40 +json_write,1,1,6509500,38.406,40 +json_write,1,2,6435100,38.850,40 +json_write,1,3,6498800,38.469,40 +json_write,1,4,6437000,38.838,40 +json_write,1,5,6528700,38.293,40 +json_write,1,6,6461400,38.695,40 +xml_read,1000,0,1300,196974.355,53795 +xml_read,1000,1,1300,193523.779,53795 +xml_read,1000,2,1300,193288.278,53795 +xml_read,1000,3,1300,194407.922,53795 +xml_read,1000,4,1300,194339.094,53795 +xml_read,1000,5,1300,194186.558,53795 +xml_read,1000,6,1300,194318.975,53795 +xml_write,1000,0,4700,54242.884,53795 +xml_write,1000,1,4700,54055.598,53795 +xml_write,1000,2,4700,54130.730,53795 +xml_write,1000,3,4700,53722.010,53795 +xml_write,1000,4,4600,55237.043,53795 +xml_write,1000,5,4600,54599.533,53795 +xml_write,1000,6,4700,53945.811,53795 +json_read,1000,0,4300,59381.010,31792 +json_read,1000,1,4200,59859.441,31792 +json_read,1000,2,3800,66094.597,31792 +json_read,1000,3,4200,60521.405,31792 +json_read,1000,4,4100,61607.553,31792 +json_read,1000,5,4200,59849.366,31792 +json_read,1000,6,3900,64464.668,31792 +json_write,1000,0,9300,27130.972,31792 +json_write,1000,1,9800,25552.999,31792 +json_write,1000,2,9600,26300.246,31792 +json_write,1000,3,9700,25775.935,31792 +json_write,1000,4,9800,25558.396,31792 +json_write,1000,5,9900,25503.478,31792 +json_write,1000,6,9800,25663.313,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-1.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-1.csv new file mode 100644 index 0000000..ded1fb4 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-1.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,827100,302.265,65 +xml_read,1,1,835800,299.142,65 +xml_read,1,2,838000,298.342,65 +xml_read,1,3,818500,305.439,65 +xml_read,1,4,838300,298.253,65 +xml_read,1,5,821600,304.300,65 +xml_read,1,6,827700,302.046,65 +xml_write,1,0,1472000,169.847,65 +xml_write,1,1,1477300,169.230,65 +xml_write,1,2,1451400,172.253,65 +xml_write,1,3,1472800,169.748,65 +xml_write,1,4,1468200,170.297,65 +xml_write,1,5,1380900,181.053,65 +xml_write,1,6,1468500,170.252,65 +json_read,1,0,3101300,80.612,40 +json_read,1,1,3058900,81.730,40 +json_read,1,2,3058200,81.750,40 +json_read,1,3,3096600,80.736,40 +json_read,1,4,2850200,87.716,40 +json_read,1,5,2814700,88.820,40 +json_read,1,6,3050500,81.954,40 +json_write,1,0,6517700,38.357,40 +json_write,1,1,6532500,38.271,40 +json_write,1,2,6443100,38.801,40 +json_write,1,3,6543900,38.204,40 +json_write,1,4,6474500,38.613,40 +json_write,1,5,6555000,38.139,40 +json_write,1,6,6396300,39.085,40 +xml_read,1000,0,1300,194550.301,53795 +xml_read,1000,1,1300,195475.397,53795 +xml_read,1000,2,1300,193534.129,53795 +xml_read,1000,3,1300,194988.368,53795 +xml_read,1000,4,1300,208725.903,53795 +xml_read,1000,5,1200,216615.794,53795 +xml_read,1000,6,1300,194719.169,53795 +xml_write,1000,0,4600,54364.215,53795 +xml_write,1000,1,4600,54431.858,53795 +xml_write,1000,2,4600,54511.729,53795 +xml_write,1000,3,4600,54633.631,53795 +xml_write,1000,4,4600,55454.983,53795 +xml_write,1000,5,4700,54051.679,53795 +xml_write,1000,6,4700,54341.717,53795 +json_read,1000,0,4200,59548.787,31792 +json_read,1000,1,4100,61384.685,31792 +json_read,1000,2,4200,60243.156,31792 +json_read,1000,3,4200,60299.806,31792 +json_read,1000,4,4300,59437.678,31792 +json_read,1000,5,4100,62199.527,31792 +json_read,1000,6,4200,59899.332,31792 +json_write,1000,0,9700,25892.306,31792 +json_write,1000,1,9800,25683.203,31792 +json_write,1000,2,9600,26286.329,31792 +json_write,1000,3,9600,26061.598,31792 +json_write,1000,4,9700,25940.777,31792 +json_write,1000,5,9700,25851.071,31792 +json_write,1000,6,9600,26062.816,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-2.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-2.csv new file mode 100644 index 0000000..65a8e77 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-2.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,836700,298.793,65 +xml_read,1,1,837900,298.393,65 +xml_read,1,2,827200,302.230,65 +xml_read,1,3,820000,304.880,65 +xml_read,1,4,827200,302.250,65 +xml_read,1,5,834300,299.685,65 +xml_read,1,6,836700,298.811,65 +xml_write,1,0,1405900,177.823,65 +xml_write,1,1,1458000,171.477,65 +xml_write,1,2,1419000,176.181,65 +xml_write,1,3,1475000,169.492,65 +xml_write,1,4,1460200,171.216,65 +xml_write,1,5,1458100,171.463,65 +xml_write,1,6,1473700,169.647,65 +json_read,1,0,3056100,81.806,40 +json_read,1,1,3058000,81.753,40 +json_read,1,2,3054300,81.854,40 +json_read,1,3,3067600,81.497,40 +json_read,1,4,3077400,81.238,40 +json_read,1,5,3044900,82.110,40 +json_read,1,6,3056800,81.787,40 +json_write,1,0,6567200,38.069,40 +json_write,1,1,6575700,38.020,40 +json_write,1,2,6558700,38.117,40 +json_write,1,3,6439500,38.823,40 +json_write,1,4,6574200,38.028,40 +json_write,1,5,6550900,38.163,40 +json_write,1,6,6460100,38.700,40 +xml_read,1000,0,1300,198859.160,53795 +xml_read,1000,1,1300,193877.262,53795 +xml_read,1000,2,1300,194307.125,53795 +xml_read,1000,3,1300,193741.719,53795 +xml_read,1000,4,1300,196396.695,53795 +xml_read,1000,5,1300,193281.126,53795 +xml_read,1000,6,1300,193835.323,53795 +xml_write,1000,0,4600,54402.957,53795 +xml_write,1000,1,4700,53987.660,53795 +xml_write,1000,2,4700,53745.045,53795 +xml_write,1000,3,4700,53872.526,53795 +xml_write,1000,4,4700,53997.303,53795 +xml_write,1000,5,4700,53766.502,53795 +xml_write,1000,6,4700,53863.432,53795 +json_read,1000,0,4200,60745.729,31792 +json_read,1000,1,4200,60356.500,31792 +json_read,1000,2,4200,60379.292,31792 +json_read,1000,3,4200,60142.929,31792 +json_read,1000,4,4200,60452.414,31792 +json_read,1000,5,4100,61367.190,31792 +json_read,1000,6,4200,60087.663,31792 +json_write,1000,0,9900,25478.016,31792 +json_write,1000,1,9800,25726.166,31792 +json_write,1000,2,9800,25664.452,31792 +json_write,1000,3,9200,27371.020,31792 +json_write,1000,4,9900,25475.268,31792 +json_write,1000,5,9600,26049.793,31792 +json_write,1000,6,9800,25551.944,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-3.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-3.csv new file mode 100644 index 0000000..121a3e0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-3.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,823900,303.449,65 +xml_read,1,1,836900,298.745,65 +xml_read,1,2,834300,299.655,65 +xml_read,1,3,823300,303.660,65 +xml_read,1,4,836800,298.781,65 +xml_read,1,5,825600,302.816,65 +xml_read,1,6,836200,298.986,65 +xml_write,1,0,1440500,173.557,65 +xml_write,1,1,1453300,172.033,65 +xml_write,1,2,1461400,171.075,65 +xml_write,1,3,1471700,169.872,65 +xml_write,1,4,1468200,170.285,65 +xml_write,1,5,1470800,169.985,65 +xml_write,1,6,1456900,171.600,65 +json_read,1,0,2970800,84.154,40 +json_read,1,1,3024800,82.651,40 +json_read,1,2,3001900,83.282,40 +json_read,1,3,3016400,82.884,40 +json_read,1,4,3020800,82.773,40 +json_read,1,5,2953300,84.657,40 +json_read,1,6,2555100,97.845,40 +json_write,1,0,6591800,37.926,40 +json_write,1,1,6517700,38.357,40 +json_write,1,2,6564000,38.087,40 +json_write,1,3,6539900,38.227,40 +json_write,1,4,6575600,38.020,40 +json_write,1,5,6552300,38.155,40 +json_write,1,6,6485000,38.551,40 +xml_read,1000,0,1300,197799.420,53795 +xml_read,1000,1,1300,193560.895,53795 +xml_read,1000,2,1300,196319.854,53795 +xml_read,1000,3,1300,194314.612,53795 +xml_read,1000,4,1200,218468.622,53795 +xml_read,1000,5,1300,195159.815,53795 +xml_read,1000,6,1300,193396.555,53795 +xml_write,1000,0,4600,55246.013,53795 +xml_write,1000,1,4600,55303.228,53795 +xml_write,1000,2,4600,55146.233,53795 +xml_write,1000,3,4500,55726.248,53795 +xml_write,1000,4,4500,55822.140,53795 +xml_write,1000,5,4500,55603.393,53795 +xml_write,1000,6,4600,55058.145,53795 +json_read,1000,0,4200,59673.417,31792 +json_read,1000,1,4200,60005.157,31792 +json_read,1000,2,4100,61997.866,31792 +json_read,1000,3,4100,61642.985,31792 +json_read,1000,4,4200,60266.894,31792 +json_read,1000,5,4200,60066.063,31792 +json_read,1000,6,4200,60875.478,31792 +json_write,1000,0,9900,25360.901,31792 +json_write,1000,1,9900,25423.381,31792 +json_write,1000,2,9700,25937.624,31792 +json_write,1000,3,9900,25449.990,31792 +json_write,1000,4,9900,25456.269,31792 +json_write,1000,5,9900,25320.466,31792 +json_write,1000,6,9900,25469.104,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-batch.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-batch.rs new file mode 100644 index 0000000..aaf3cf2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed-batch.rs @@ -0,0 +1,307 @@ +// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML) +#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)] + +use std::borrow::Cow; +use serde::{Deserialize, Serialize}; +use std::str::FromStr; +use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; +use quick_xml::{Reader, Writer}; +use polyxml::{PolyXmlError, Result}; + +#[allow(dead_code)] +pub(crate) fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> { + let mut depth = 1; + loop { + match reader.read_event()? { + Event::Start(_) => depth += 1, + Event::End(_) => { + depth -= 1; + if depth == 0 { + break; + } + } + Event::Eof => break, + _ => {} + } + } + Ok(()) +} + +#[allow(dead_code)] +pub(crate) fn read_element_text<'a>(reader: &mut Reader<&'a [u8]>, tag_name: &str) -> Result> { + let mut text = Cow::Borrowed(""); + loop { + match reader.read_event()? { + Event::Text(t) => { + let raw = match t.into_inner() { + Cow::Borrowed(b) => match quick_xml::escape::unescape(b)? { + Cow::Borrowed(s) => Cow::Borrowed(s), + Cow::Owned(s) => Cow::Owned(s), + }, + Cow::Owned(s) => Cow::Owned(quick_xml::escape::unescape(&s)?.into_owned()), + }; + if text.is_empty() { + text = raw; + } else { + text.to_mut().push_str(&raw); + } + } + Event::CData(c) => { + text.to_mut().push_str(c.as_ref()); + } + Event::GeneralRef(r) => { + if r.is_char_ref() { + if let Some(ch) = r.resolve_char_ref()? { + text.to_mut().push(ch); + } + } else if let Some(val) = quick_xml::escape::resolve_xml_entity(r.as_ref()) { + text.to_mut().push_str(val); + } else { + text.to_mut().push_str(r.as_ref()); + } + } + Event::End(e) if e.local_name().as_ref() == tag_name => break, + Event::Eof => break, + _ => {} + } + } + Ok(text) +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct BatchType<'a> { + #[serde(rename = "Sensor", default, skip_serializing_if = "Vec::is_empty")] + pub sensor: Vec>, +} + +impl<'a> BatchType<'a> { + pub fn from_xml(xml: &'a str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing BatchType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &'a [u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'a [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_sensor = Vec::new(); + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml(reader, &e)?; + var_sensor.push(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml_empty(&e)?; + var_sensor.push(val); + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let var_sensor = Vec::new(); + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &'a str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("BatchType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + for item in &self.sensor { + item.encode_xml(writer, Some("Sensor"))?; + } + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct SensorType<'a> { + #[serde(rename = "Id")] + pub id: Cow<'a, str>, + #[serde(rename = "Value")] + pub value: i32, +} + +impl<'a> SensorType<'a> { + pub fn from_xml(xml: &'a str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing SensorType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &'a [u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'a [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_id = None; + let mut var_value = None; + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Id" => { + let text = read_element_text(reader, "Id")?; + var_id = Some(text); + } + "Value" => { + let text = read_element_text(reader, "Value")?; + let s = text.trim(); + let val = s.parse::().map_err(|_| PolyXmlError::ScalarParseError { field: "value".into(), expected: "i32", value: s.into() })?; + var_value = Some(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Id" => { + var_id = Some(Cow::Borrowed("")); + } + "Value" => { + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + id: var_id.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Id'".into()))?, + value: var_value.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Value'".into()))?, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let mut var_id = None; + let mut var_value = None; + + Ok(Self { + id: var_id.unwrap_or(Cow::Borrowed("")), + value: var_value.unwrap_or_default(), + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &'a str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("SensorType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + writer.write_event(Event::Start(BytesStart::new("Id")))?; + writer.write_event(Event::Text(BytesText::new(self.id.as_ref())))?; + writer.write_event(Event::End(BytesEnd::new("Id")))?; + writer.write_event(Event::Start(BytesStart::new("Value")))?; + writer.write_event(Event::Text(BytesText::new(&self.value.to_string())))?; + writer.write_event(Event::End(BytesEnd::new("Value")))?; + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +pub type Batch<'a> = BatchType<'a>; diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed.lock new file mode 100644 index 0000000..f8e578e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-borrowed.lock @@ -0,0 +1,320 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-regression" +version = "0.0.0" +dependencies = [ + "polyxml", + "quick-xml", + "serde", + "serde_json", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-build.txt new file mode 100644 index 0000000..8e4990c --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-build.txt @@ -0,0 +1,16 @@ +memcap: <=7882 MiB (60% of 13137 MiB available) [systemd MemoryMax, swap off] + Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s +Parsing schema: /home/bailey/github/PolyXML/benchmarks/workloads/sensor-batch/batch.xsd + Types: 2 total (2 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 1 +Code generation complete. +memcap: <=7879 MiB (60% of 13133 MiB available) [systemd MemoryMax, swap off] + Compiling xml-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/baseline-borrowed) + Finished `release` profile [optimized] target(s) in 0.86s +Parsing schema: /home/bailey/github/PolyXML/benchmarks/workloads/sensor-batch/batch.xsd + Types: 2 total (2 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 1 +Code generation complete. +memcap: <=7863 MiB (60% of 13105 MiB available) [systemd MemoryMax, swap off] + Compiling xml-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/baseline-owned) + Finished `release` profile [optimized] target(s) in 0.82s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-0.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-0.csv new file mode 100644 index 0000000..8251406 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-0.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,795800,314.169,65 +xml_read,1,1,808700,309.175,65 +xml_read,1,2,806300,310.086,65 +xml_read,1,3,795000,314.491,65 +xml_read,1,4,799800,312.604,65 +xml_read,1,5,803200,311.266,65 +xml_read,1,6,679800,367.770,65 +xml_write,1,0,1299700,192.353,65 +xml_write,1,1,1127600,221.723,65 +xml_write,1,2,1345300,185.840,65 +xml_write,1,3,1446700,172.817,65 +xml_write,1,4,1435300,174.185,65 +xml_write,1,5,1426900,175.216,65 +xml_write,1,6,1449400,172.488,65 +json_read,1,0,3104600,80.528,40 +json_read,1,1,2964900,84.321,40 +json_read,1,2,3072900,81.357,40 +json_read,1,3,3089700,80.916,40 +json_read,1,4,3107300,80.456,40 +json_read,1,5,3097000,80.725,40 +json_read,1,6,2966200,84.284,40 +json_write,1,0,6843900,36.529,40 +json_write,1,1,6830500,36.601,40 +json_write,1,2,6689900,37.370,40 +json_write,1,3,6625400,37.734,40 +json_write,1,4,6724400,37.178,40 +json_write,1,5,6806600,36.730,40 +json_write,1,6,6752400,37.024,40 +xml_read,1000,0,1100,234881.526,53795 +xml_read,1000,1,1100,232710.566,53795 +xml_read,1000,2,1100,232065.497,53795 +xml_read,1000,3,1100,235787.408,53795 +xml_read,1000,4,1100,235067.604,53795 +xml_read,1000,5,1100,234370.285,53795 +xml_read,1000,6,1100,232179.158,53795 +xml_write,1000,0,3100,81013.157,53795 +xml_write,1000,1,3200,79743.778,53795 +xml_write,1000,2,3200,80072.897,53795 +xml_write,1000,3,3100,82935.047,53795 +xml_write,1000,4,3100,82070.360,53795 +xml_write,1000,5,3100,83177.319,53795 +xml_write,1000,6,3200,80072.844,53795 +json_read,1000,0,4200,59714.763,31792 +json_read,1000,1,4300,59379.771,31792 +json_read,1000,2,4300,58643.805,31792 +json_read,1000,3,4300,58791.488,31792 +json_read,1000,4,4200,59602.864,31792 +json_read,1000,5,4200,59559.660,31792 +json_read,1000,6,4300,58540.260,31792 +json_write,1000,0,10300,24357.375,31792 +json_write,1000,1,10300,24389.013,31792 +json_write,1000,2,10200,24526.810,31792 +json_write,1000,3,10400,24212.869,31792 +json_write,1000,4,10300,24354.440,31792 +json_write,1000,5,10400,24253.103,31792 +json_write,1000,6,10200,24699.049,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-1.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-1.csv new file mode 100644 index 0000000..eeaaf14 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-1.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,800200,312.455,65 +xml_read,1,1,805100,310.521,65 +xml_read,1,2,800400,312.357,65 +xml_read,1,3,774800,322.684,65 +xml_read,1,4,798600,313.057,65 +xml_read,1,5,794300,314.759,65 +xml_read,1,6,793500,315.095,65 +xml_write,1,0,1424300,175.526,65 +xml_write,1,1,1430400,174.784,65 +xml_write,1,2,1442300,173.344,65 +xml_write,1,3,1444200,173.111,65 +xml_write,1,4,1417100,176.423,65 +xml_write,1,5,1426200,175.296,65 +xml_write,1,6,1440000,173.617,65 +json_read,1,0,3126400,79.967,40 +json_read,1,1,3080000,81.170,40 +json_read,1,2,3100200,80.641,40 +json_read,1,3,3134100,79.768,40 +json_read,1,4,3134300,79.764,40 +json_read,1,5,3082100,81.114,40 +json_read,1,6,3030600,82.493,40 +json_write,1,0,6963900,35.900,40 +json_write,1,1,6682900,37.409,40 +json_write,1,2,6274500,39.846,40 +json_write,1,3,6711000,37.253,40 +json_write,1,4,6535400,38.253,40 +json_write,1,5,6875500,36.361,40 +json_write,1,6,6886300,36.304,40 +xml_read,1000,0,1100,234531.013,53795 +xml_read,1000,1,1100,234375.853,53795 +xml_read,1000,2,1100,232379.026,53795 +xml_read,1000,3,1100,241694.761,53795 +xml_read,1000,4,1100,237494.745,53795 +xml_read,1000,5,1100,233017.616,53795 +xml_read,1000,6,1100,232677.723,53795 +xml_write,1000,0,3100,81040.227,53795 +xml_write,1000,1,3200,80491.116,53795 +xml_write,1000,2,3200,79598.096,53795 +xml_write,1000,3,3200,79972.305,53795 +xml_write,1000,4,3200,80028.895,53795 +xml_write,1000,5,3100,81490.317,53795 +xml_write,1000,6,3200,80084.668,53795 +json_read,1000,0,4300,58916.820,31792 +json_read,1000,1,4200,60601.782,31792 +json_read,1000,2,4300,58870.787,31792 +json_read,1000,3,4300,58786.729,31792 +json_read,1000,4,4300,59110.761,31792 +json_read,1000,5,4000,63461.367,31792 +json_read,1000,6,4100,61018.687,31792 +json_write,1000,0,10400,24218.739,31792 +json_write,1000,1,10400,24265.931,31792 +json_write,1000,2,10200,24527.493,31792 +json_write,1000,3,10300,24288.611,31792 +json_write,1000,4,10300,24277.874,31792 +json_write,1000,5,10300,24370.849,31792 +json_write,1000,6,10300,24369.074,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-2.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-2.csv new file mode 100644 index 0000000..7dd1f2d --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-2.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,795300,314.359,65 +xml_read,1,1,788400,317.125,65 +xml_read,1,2,794400,314.716,65 +xml_read,1,3,803300,311.238,65 +xml_read,1,4,799300,313.611,65 +xml_read,1,5,766900,326.015,65 +xml_read,1,6,789800,316.561,65 +xml_write,1,0,1448600,172.590,65 +xml_write,1,1,1424300,175.529,65 +xml_write,1,2,1433600,174.395,65 +xml_write,1,3,1439100,173.729,65 +xml_write,1,4,1441500,173.441,65 +xml_write,1,5,1445400,172.974,65 +xml_write,1,6,1423400,175.640,65 +json_read,1,0,2893600,86.399,40 +json_read,1,1,2958900,84.492,40 +json_read,1,2,3084800,81.044,40 +json_read,1,3,3042500,82.171,40 +json_read,1,4,2863900,87.296,40 +json_read,1,5,3035300,82.365,40 +json_read,1,6,3059200,81.721,40 +json_write,1,0,6902200,36.220,40 +json_write,1,1,6863500,36.425,40 +json_write,1,2,6941100,36.018,40 +json_write,1,3,6952700,35.958,40 +json_write,1,4,6926600,36.093,40 +json_write,1,5,6893300,36.267,40 +json_write,1,6,6949400,35.975,40 +xml_read,1000,0,1100,234565.702,53795 +xml_read,1000,1,1100,236103.058,53795 +xml_read,1000,2,1100,233371.684,53795 +xml_read,1000,3,1100,232632.681,53795 +xml_read,1000,4,1100,233462.384,53795 +xml_read,1000,5,1100,235375.129,53795 +xml_read,1000,6,1100,236087.523,53795 +xml_write,1000,0,3200,80047.011,53795 +xml_write,1000,1,3200,80506.778,53795 +xml_write,1000,2,3200,80528.736,53795 +xml_write,1000,3,3200,80257.470,53795 +xml_write,1000,4,3200,79730.535,53795 +xml_write,1000,5,3200,79775.233,53795 +xml_write,1000,6,3200,80083.359,53795 +json_read,1000,0,4300,58966.840,31792 +json_read,1000,1,4300,58748.036,31792 +json_read,1000,2,4300,58818.102,31792 +json_read,1000,3,4300,58892.167,31792 +json_read,1000,4,4300,58822.587,31792 +json_read,1000,5,4300,58624.143,31792 +json_read,1000,6,4300,58870.936,31792 +json_write,1000,0,10500,23927.814,31792 +json_write,1000,1,10500,23934.693,31792 +json_write,1000,2,10000,25063.577,31792 +json_write,1000,3,10300,24493.627,31792 +json_write,1000,4,10500,23898.855,31792 +json_write,1000,5,10100,24844.458,31792 +json_write,1000,6,10500,23863.931,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-3.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-3.csv new file mode 100644 index 0000000..111f9fd --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-3.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,794200,314.790,65 +xml_read,1,1,797400,313.543,65 +xml_read,1,2,803400,311.206,65 +xml_read,1,3,804800,310.671,65 +xml_read,1,4,787400,317.539,65 +xml_read,1,5,800900,312.174,65 +xml_read,1,6,789800,316.559,65 +xml_write,1,0,1445800,172.925,65 +xml_write,1,1,1353900,184.659,65 +xml_write,1,2,1427600,175.124,65 +xml_write,1,3,1418300,176.269,65 +xml_write,1,4,1449000,172.539,65 +xml_write,1,5,1390400,179.816,65 +xml_write,1,6,1445000,173.012,65 +json_read,1,0,3099200,80.666,40 +json_read,1,1,3118100,80.178,40 +json_read,1,2,3084300,81.057,40 +json_read,1,3,3103600,80.553,40 +json_read,1,4,3125000,80.002,40 +json_read,1,5,3120000,80.130,40 +json_read,1,6,3103400,80.559,40 +json_write,1,0,6954000,35.951,40 +json_write,1,1,6883900,36.317,40 +json_write,1,2,6959300,35.923,40 +json_write,1,3,6925300,36.100,40 +json_write,1,4,6920500,36.125,40 +json_write,1,5,6725500,37.172,40 +json_write,1,6,6926700,36.093,40 +xml_read,1000,0,1100,238280.059,53795 +xml_read,1000,1,1100,238401.529,53795 +xml_read,1000,2,1100,237285.868,53795 +xml_read,1000,3,1100,238183.975,53795 +xml_read,1000,4,1100,241714.864,53795 +xml_read,1000,5,1100,237900.462,53795 +xml_read,1000,6,1100,235393.416,53795 +xml_write,1000,0,3200,80058.641,53795 +xml_write,1000,1,3200,80004.085,53795 +xml_write,1000,2,3200,80455.277,53795 +xml_write,1000,3,3200,80079.414,53795 +xml_write,1000,4,3200,79957.538,53795 +xml_write,1000,5,3200,80159.280,53795 +xml_write,1000,6,3200,80319.059,53795 +json_read,1000,0,4300,58557.430,31792 +json_read,1000,1,4300,59034.481,31792 +json_read,1000,2,4200,60622.545,31792 +json_read,1000,3,4100,61531.300,31792 +json_read,1000,4,4200,60303.164,31792 +json_read,1000,5,4300,58856.163,31792 +json_read,1000,6,4200,62115.064,31792 +json_write,1000,0,10500,24023.045,31792 +json_write,1000,1,10000,25024.962,31792 +json_write,1000,2,10300,24376.999,31792 +json_write,1000,3,10300,24422.748,31792 +json_write,1000,4,10500,23998.653,31792 +json_write,1000,5,10500,23991.090,31792 +json_write,1000,6,10400,24199.072,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-batch.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-batch.rs new file mode 100644 index 0000000..1b02437 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned-batch.rs @@ -0,0 +1,297 @@ +// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML) +#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)] + +use std::borrow::Cow; +use serde::{Deserialize, Serialize}; +use std::str::FromStr; +use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; +use quick_xml::{Reader, Writer}; +use polyxml::{PolyXmlError, Result}; + +#[allow(dead_code)] +pub(crate) fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> { + let mut depth = 1; + loop { + match reader.read_event()? { + Event::Start(_) => depth += 1, + Event::End(_) => { + depth -= 1; + if depth == 0 { + break; + } + } + Event::Eof => break, + _ => {} + } + } + Ok(()) +} + +#[allow(dead_code)] +pub(crate) fn read_element_text(reader: &mut Reader<&[u8]>, tag_name: &str) -> Result { + let mut text = String::new(); + loop { + match reader.read_event()? { + Event::Text(t) => { + let unescaped = quick_xml::escape::unescape(t.as_ref())?; + text.push_str(&unescaped); + } + Event::CData(c) => { + text.push_str(c.as_ref()); + } + Event::GeneralRef(r) => { + if r.is_char_ref() { + if let Some(ch) = r.resolve_char_ref()? { + text.push(ch); + } + } else if let Some(val) = quick_xml::escape::resolve_xml_entity(r.as_ref()) { + text.push_str(val); + } else { + text.push_str(r.as_ref()); + } + } + Event::End(e) if e.local_name().as_ref() == tag_name => break, + Event::Eof => break, + _ => {} + } + } + Ok(text) +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct BatchType { + #[serde(rename = "Sensor", default, skip_serializing_if = "Vec::is_empty")] + pub sensor: Vec, +} + +impl BatchType { + pub fn from_xml(xml: &str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing BatchType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &[u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'_ [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_sensor = Vec::new(); + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml(reader, &e)?; + var_sensor.push(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml_empty(&e)?; + var_sensor.push(val); + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let var_sensor = Vec::new(); + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &[u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("BatchType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + for item in &self.sensor { + item.encode_xml(writer, Some("Sensor"))?; + } + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct SensorType { + #[serde(rename = "Id")] + pub id: String, + #[serde(rename = "Value")] + pub value: i32, +} + +impl SensorType { + pub fn from_xml(xml: &str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing SensorType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &[u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'_ [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_id = None; + let mut var_value = None; + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Id" => { + let text = read_element_text(reader, "Id")?; + var_id = Some(text); + } + "Value" => { + let text = read_element_text(reader, "Value")?; + let s = text.trim(); + let val = s.parse::().map_err(|_| PolyXmlError::ScalarParseError { field: "value".into(), expected: "i32", value: s.into() })?; + var_value = Some(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Id" => { + var_id = Some(String::new()); + } + "Value" => { + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + id: var_id.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Id'".into()))?, + value: var_value.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Value'".into()))?, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let mut var_id = None; + let mut var_value = None; + + Ok(Self { + id: var_id.unwrap_or_default(), + value: var_value.unwrap_or_default(), + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &[u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("SensorType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + writer.write_event(Event::Start(BytesStart::new("Id")))?; + writer.write_event(Event::Text(BytesText::new(self.id.as_ref())))?; + writer.write_event(Event::End(BytesEnd::new("Id")))?; + writer.write_event(Event::Start(BytesStart::new("Value")))?; + writer.write_event(Event::Text(BytesText::new(&self.value.to_string())))?; + writer.write_event(Event::End(BytesEnd::new("Value")))?; + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +pub type Batch = BatchType; diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned.lock new file mode 100644 index 0000000..f8e578e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/baseline-owned.lock @@ -0,0 +1,320 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-regression" +version = "0.0.0" +dependencies = [ + "polyxml", + "quick-xml", + "serde", + "serde_json", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-0.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-0.csv new file mode 100644 index 0000000..318bcdd --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-0.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,867700,288.124,65 +xml_read,1,1,875100,285.699,65 +xml_read,1,2,858700,291.140,65 +xml_read,1,3,874100,286.029,65 +xml_read,1,4,871900,286.761,65 +xml_read,1,5,859600,290.845,65 +xml_read,1,6,856200,292.002,65 +xml_write,1,0,1459500,171.300,65 +xml_write,1,1,1423900,175.580,65 +xml_write,1,2,1467600,170.350,65 +xml_write,1,3,1477900,169.163,65 +xml_write,1,4,1458400,171.425,65 +xml_write,1,5,1415600,176.604,65 +xml_write,1,6,1470500,170.011,65 +json_read,1,0,3147900,79.420,40 +json_read,1,1,3149500,79.378,40 +json_read,1,2,3118900,80.158,40 +json_read,1,3,2709900,92.258,40 +json_read,1,4,2528200,98.886,40 +json_read,1,5,3133200,79.792,40 +json_read,1,6,3116000,80.233,40 +json_write,1,0,6339800,39.433,40 +json_write,1,1,6330800,39.490,40 +json_write,1,2,6282700,39.792,40 +json_write,1,3,6294300,39.719,40 +json_write,1,4,6170900,40.513,40 +json_write,1,5,6325600,39.522,40 +json_write,1,6,6347200,39.388,40 +xml_read,1000,0,1400,185572.847,53795 +xml_read,1000,1,1300,199117.155,53795 +xml_read,1000,2,1400,185182.185,53795 +xml_read,1000,3,1400,190077.543,53795 +xml_read,1000,4,1400,188404.031,53795 +xml_read,1000,5,1400,186515.871,53795 +xml_read,1000,6,1400,183590.206,53795 +xml_write,1000,0,4900,51510.687,53795 +xml_write,1000,1,4900,51807.319,53795 +xml_write,1000,2,4900,52003.825,53795 +xml_write,1000,3,4900,51633.096,53795 +xml_write,1000,4,4800,52469.891,53795 +xml_write,1000,5,4900,51891.641,53795 +xml_write,1000,6,4900,51877.138,53795 +json_read,1000,0,4300,59086.543,31792 +json_read,1000,1,4300,59175.735,31792 +json_read,1000,2,4300,59217.093,31792 +json_read,1000,3,4300,58693.281,31792 +json_read,1000,4,4300,58536.687,31792 +json_read,1000,5,4200,60142.987,31792 +json_read,1000,6,4100,61850.753,31792 +json_write,1000,0,9800,25747.608,31792 +json_write,1000,1,9600,26173.044,31792 +json_write,1000,2,9600,26074.351,31792 +json_write,1000,3,9700,25829.752,31792 +json_write,1000,4,9800,25759.705,31792 +json_write,1000,5,9600,26226.341,31792 +json_write,1000,6,9600,26270.255,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-1.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-1.csv new file mode 100644 index 0000000..931dcc0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-1.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,820300,304.772,65 +xml_read,1,1,857900,291.428,65 +xml_read,1,2,872800,286.435,65 +xml_read,1,3,876000,285.419,65 +xml_read,1,4,875300,285.627,65 +xml_read,1,5,880100,284.065,65 +xml_read,1,6,873500,286.220,65 +xml_write,1,0,1436600,174.023,65 +xml_write,1,1,1465000,170.649,65 +xml_write,1,2,1460600,171.172,65 +xml_write,1,3,1459800,171.261,65 +xml_write,1,4,1456800,171.610,65 +xml_write,1,5,1462000,171.003,65 +xml_write,1,6,1470500,170.016,65 +json_read,1,0,3108200,80.433,40 +json_read,1,1,3047200,82.043,40 +json_read,1,2,3125700,79.983,40 +json_read,1,3,3123600,80.038,40 +json_read,1,4,3110500,80.375,40 +json_read,1,5,3024600,82.658,40 +json_read,1,6,3088300,80.952,40 +json_write,1,0,6440900,38.815,40 +json_write,1,1,6384300,39.159,40 +json_write,1,2,6311700,39.609,40 +json_write,1,3,6453600,38.742,40 +json_write,1,4,6424100,38.916,40 +json_write,1,5,6425500,38.908,40 +json_write,1,6,6423200,38.921,40 +xml_read,1000,0,1400,185125.716,53795 +xml_read,1000,1,1400,183681.419,53795 +xml_read,1000,2,1400,185165.041,53795 +xml_read,1000,3,1400,189958.734,53795 +xml_read,1000,4,1400,187201.494,53795 +xml_read,1000,5,1400,186176.256,53795 +xml_read,1000,6,1400,184560.001,53795 +xml_write,1000,0,4700,54091.711,53795 +xml_write,1000,1,4800,52769.267,53795 +xml_write,1000,2,4800,53031.882,53795 +xml_write,1000,3,4700,53319.171,53795 +xml_write,1000,4,4800,52894.629,53795 +xml_write,1000,5,4800,52925.848,53795 +xml_write,1000,6,4800,52839.415,53795 +json_read,1000,0,4300,58536.248,31792 +json_read,1000,1,4200,59854.393,31792 +json_read,1000,2,4300,58567.573,31792 +json_read,1000,3,4100,62230.709,31792 +json_read,1000,4,4300,58687.475,31792 +json_read,1000,5,4100,61178.198,31792 +json_read,1000,6,4300,58710.255,31792 +json_write,1000,0,9200,27190.392,31792 +json_write,1000,1,9700,25828.776,31792 +json_write,1000,2,9700,25881.721,31792 +json_write,1000,3,9700,25893.517,31792 +json_write,1000,4,9700,25959.446,31792 +json_write,1000,5,9800,25659.508,31792 +json_write,1000,6,9700,25797.052,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-2.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-2.csv new file mode 100644 index 0000000..4d86817 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-2.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,865500,288.876,65 +xml_read,1,1,851200,293.754,65 +xml_read,1,2,791100,316.025,65 +xml_read,1,3,876700,285.186,65 +xml_read,1,4,870000,287.372,65 +xml_read,1,5,878200,284.673,65 +xml_read,1,6,872100,286.686,65 +xml_write,1,0,1460300,171.205,65 +xml_write,1,1,1463700,170.801,65 +xml_write,1,2,1462000,170.999,65 +xml_write,1,3,1466000,170.535,65 +xml_write,1,4,1453000,172.063,65 +xml_write,1,5,1466800,170.444,65 +xml_write,1,6,1471700,169.873,65 +json_read,1,0,3139200,79.639,40 +json_read,1,1,3116900,80.209,40 +json_read,1,2,3038600,82.279,40 +json_read,1,3,3066000,81.540,40 +json_read,1,4,3037900,82.296,40 +json_read,1,5,2754000,90.777,40 +json_read,1,6,3130000,79.875,40 +json_write,1,0,6035400,41.423,40 +json_write,1,1,6028300,41.471,40 +json_write,1,2,6021700,41.517,40 +json_write,1,3,5959700,41.949,40 +json_write,1,4,6067500,41.204,40 +json_write,1,5,6028500,41.470,40 +json_write,1,6,5923500,42.205,40 +xml_read,1000,0,1400,191493.247,53795 +xml_read,1000,1,1400,184026.999,53795 +xml_read,1000,2,1400,185548.487,53795 +xml_read,1000,3,1400,190014.786,53795 +xml_read,1000,4,1300,198914.119,53795 +xml_read,1000,5,1400,184260.099,53795 +xml_read,1000,6,1400,185902.056,53795 +xml_write,1000,0,4900,51360.579,53795 +xml_write,1000,1,4900,51947.634,53795 +xml_write,1000,2,4900,51475.889,53795 +xml_write,1000,3,4800,52510.231,53795 +xml_write,1000,4,4900,51408.213,53795 +xml_write,1000,5,4900,51501.487,53795 +xml_write,1000,6,4900,51307.094,53795 +json_read,1000,0,4300,58993.732,31792 +json_read,1000,1,4300,58539.976,31792 +json_read,1000,2,4200,59727.329,31792 +json_read,1000,3,4300,59331.218,31792 +json_read,1000,4,4300,59093.242,31792 +json_read,1000,5,4300,59244.156,31792 +json_read,1000,6,4300,58871.678,31792 +json_write,1000,0,9800,25704.837,31792 +json_write,1000,1,9600,26128.698,31792 +json_write,1000,2,9700,25814.005,31792 +json_write,1000,3,9700,25923.772,31792 +json_write,1000,4,9700,25886.729,31792 +json_write,1000,5,9800,25736.427,31792 +json_write,1000,6,9800,25668.008,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-3.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-3.csv new file mode 100644 index 0000000..76642d3 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-3.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,864600,289.155,65 +xml_read,1,1,850700,293.884,65 +xml_read,1,2,876000,285.418,65 +xml_read,1,3,867800,288.088,65 +xml_read,1,4,873900,286.077,65 +xml_read,1,5,879100,284.395,65 +xml_read,1,6,870700,287.129,65 +xml_write,1,0,1447600,172.710,65 +xml_write,1,1,1425500,175.383,65 +xml_write,1,2,1474400,169.570,65 +xml_write,1,3,1471300,169.927,65 +xml_write,1,4,1472600,169.777,65 +xml_write,1,5,1453400,172.017,65 +xml_write,1,6,1436300,174.064,65 +json_read,1,0,3050300,81.960,40 +json_read,1,1,3101500,80.609,40 +json_read,1,2,3105000,80.517,40 +json_read,1,3,3125900,79.979,40 +json_read,1,4,3127800,79.929,40 +json_read,1,5,3141600,79.579,40 +json_read,1,6,3122900,80.054,40 +json_write,1,0,6081200,41.111,40 +json_write,1,1,6097200,41.003,40 +json_write,1,2,6098100,40.997,40 +json_write,1,3,6074400,41.156,40 +json_write,1,4,5854600,42.702,40 +json_write,1,5,5935600,42.120,40 +json_write,1,6,6011700,41.586,40 +xml_read,1000,0,1400,190365.578,53795 +xml_read,1000,1,1400,191599.286,53795 +xml_read,1000,2,1400,184137.024,53795 +xml_read,1000,3,1400,184363.999,53795 +xml_read,1000,4,1400,187084.321,53795 +xml_read,1000,5,1400,185500.684,53795 +xml_read,1000,6,1400,185555.551,53795 +xml_write,1000,0,4900,51462.179,53795 +xml_write,1000,1,4900,51465.811,53795 +xml_write,1000,2,4900,51382.035,53795 +xml_write,1000,3,4900,51364.249,53795 +xml_write,1000,4,4900,51420.229,53795 +xml_write,1000,5,4900,51769.206,53795 +xml_write,1000,6,4900,51213.117,53795 +json_read,1000,0,4300,58388.971,31792 +json_read,1000,1,4300,58713.370,31792 +json_read,1000,2,4200,60100.317,31792 +json_read,1000,3,4300,59117.632,31792 +json_read,1000,4,4300,58490.480,31792 +json_read,1000,5,4300,58682.389,31792 +json_read,1000,6,4200,60225.274,31792 +json_write,1000,0,9400,26623.426,31792 +json_write,1000,1,9000,28061.242,31792 +json_write,1000,2,9400,26772.551,31792 +json_write,1000,3,9300,27062.949,31792 +json_write,1000,4,9500,26528.981,31792 +json_write,1000,5,9400,26876.503,31792 +json_write,1000,6,9300,26901.149,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-batch.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-batch.rs new file mode 100644 index 0000000..aaf3cf2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed-batch.rs @@ -0,0 +1,307 @@ +// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML) +#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)] + +use std::borrow::Cow; +use serde::{Deserialize, Serialize}; +use std::str::FromStr; +use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; +use quick_xml::{Reader, Writer}; +use polyxml::{PolyXmlError, Result}; + +#[allow(dead_code)] +pub(crate) fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> { + let mut depth = 1; + loop { + match reader.read_event()? { + Event::Start(_) => depth += 1, + Event::End(_) => { + depth -= 1; + if depth == 0 { + break; + } + } + Event::Eof => break, + _ => {} + } + } + Ok(()) +} + +#[allow(dead_code)] +pub(crate) fn read_element_text<'a>(reader: &mut Reader<&'a [u8]>, tag_name: &str) -> Result> { + let mut text = Cow::Borrowed(""); + loop { + match reader.read_event()? { + Event::Text(t) => { + let raw = match t.into_inner() { + Cow::Borrowed(b) => match quick_xml::escape::unescape(b)? { + Cow::Borrowed(s) => Cow::Borrowed(s), + Cow::Owned(s) => Cow::Owned(s), + }, + Cow::Owned(s) => Cow::Owned(quick_xml::escape::unescape(&s)?.into_owned()), + }; + if text.is_empty() { + text = raw; + } else { + text.to_mut().push_str(&raw); + } + } + Event::CData(c) => { + text.to_mut().push_str(c.as_ref()); + } + Event::GeneralRef(r) => { + if r.is_char_ref() { + if let Some(ch) = r.resolve_char_ref()? { + text.to_mut().push(ch); + } + } else if let Some(val) = quick_xml::escape::resolve_xml_entity(r.as_ref()) { + text.to_mut().push_str(val); + } else { + text.to_mut().push_str(r.as_ref()); + } + } + Event::End(e) if e.local_name().as_ref() == tag_name => break, + Event::Eof => break, + _ => {} + } + } + Ok(text) +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct BatchType<'a> { + #[serde(rename = "Sensor", default, skip_serializing_if = "Vec::is_empty")] + pub sensor: Vec>, +} + +impl<'a> BatchType<'a> { + pub fn from_xml(xml: &'a str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing BatchType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &'a [u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'a [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_sensor = Vec::new(); + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml(reader, &e)?; + var_sensor.push(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml_empty(&e)?; + var_sensor.push(val); + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let var_sensor = Vec::new(); + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &'a str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("BatchType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + for item in &self.sensor { + item.encode_xml(writer, Some("Sensor"))?; + } + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct SensorType<'a> { + #[serde(rename = "Id")] + pub id: Cow<'a, str>, + #[serde(rename = "Value")] + pub value: i32, +} + +impl<'a> SensorType<'a> { + pub fn from_xml(xml: &'a str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing SensorType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &'a [u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'a [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_id = None; + let mut var_value = None; + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Id" => { + let text = read_element_text(reader, "Id")?; + var_id = Some(text); + } + "Value" => { + let text = read_element_text(reader, "Value")?; + let s = text.trim(); + let val = s.parse::().map_err(|_| PolyXmlError::ScalarParseError { field: "value".into(), expected: "i32", value: s.into() })?; + var_value = Some(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Id" => { + var_id = Some(Cow::Borrowed("")); + } + "Value" => { + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + id: var_id.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Id'".into()))?, + value: var_value.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Value'".into()))?, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let mut var_id = None; + let mut var_value = None; + + Ok(Self { + id: var_id.unwrap_or(Cow::Borrowed("")), + value: var_value.unwrap_or_default(), + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &'a str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("SensorType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + writer.write_event(Event::Start(BytesStart::new("Id")))?; + writer.write_event(Event::Text(BytesText::new(self.id.as_ref())))?; + writer.write_event(Event::End(BytesEnd::new("Id")))?; + writer.write_event(Event::Start(BytesStart::new("Value")))?; + writer.write_event(Event::Text(BytesText::new(&self.value.to_string())))?; + writer.write_event(Event::End(BytesEnd::new("Value")))?; + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +pub type Batch<'a> = BatchType<'a>; diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed.lock new file mode 100644 index 0000000..f8e578e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-borrowed.lock @@ -0,0 +1,320 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-regression" +version = "0.0.0" +dependencies = [ + "polyxml", + "quick-xml", + "serde", + "serde_json", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-build.txt new file mode 100644 index 0000000..9bdd199 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-build.txt @@ -0,0 +1,20 @@ +memcap: <=7839 MiB (60% of 13066 MiB available) [systemd MemoryMax, swap off] + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling polyxml-cli v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-cli) + Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.95s +Parsing schema: /home/bailey/github/PolyXML/benchmarks/workloads/sensor-batch/batch.xsd + Types: 2 total (2 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 1 +Code generation complete. +memcap: <=7840 MiB (60% of 13066 MiB available) [systemd MemoryMax, swap off] + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling xml-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/current-borrowed) + Finished `release` profile [optimized] target(s) in 24.92s +Parsing schema: /home/bailey/github/PolyXML/benchmarks/workloads/sensor-batch/batch.xsd + Types: 2 total (2 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 1 +Code generation complete. +memcap: <=7818 MiB (60% of 13030 MiB available) [systemd MemoryMax, swap off] + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling xml-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/current-owned) + Finished `release` profile [optimized] target(s) in 24.83s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-0.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-0.csv new file mode 100644 index 0000000..06fdd45 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-0.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,800000,312.520,65 +xml_read,1,1,803100,311.323,65 +xml_read,1,2,761400,328.377,65 +xml_read,1,3,778500,321.143,65 +xml_read,1,4,790300,316.346,65 +xml_read,1,5,801000,312.138,65 +xml_read,1,6,800600,312.279,65 +xml_write,1,0,1380000,181.166,65 +xml_write,1,1,1413600,176.858,65 +xml_write,1,2,1384400,180.588,65 +xml_write,1,3,1410100,177.296,65 +xml_write,1,4,1388300,180.078,65 +xml_write,1,5,1389800,179.891,65 +xml_write,1,6,1391300,179.690,65 +json_read,1,0,3048600,82.006,40 +json_read,1,1,3036100,82.343,40 +json_read,1,2,3106500,80.478,40 +json_read,1,3,3105000,80.516,40 +json_read,1,4,3079300,81.188,40 +json_read,1,5,3084000,81.066,40 +json_read,1,6,3116500,80.220,40 +json_write,1,0,6851000,36.491,40 +json_write,1,1,6769800,36.929,40 +json_write,1,2,6733600,37.127,40 +json_write,1,3,6861700,36.434,40 +json_write,1,4,6737200,37.108,40 +json_write,1,5,6705000,37.286,40 +json_write,1,6,6812200,36.699,40 +xml_read,1000,0,1100,231946.629,53795 +xml_read,1000,1,1100,232801.199,53795 +xml_read,1000,2,1100,234026.129,53795 +xml_read,1000,3,1100,236276.300,53795 +xml_read,1000,4,1100,232669.983,53795 +xml_read,1000,5,1100,233177.855,53795 +xml_read,1000,6,1100,234965.029,53795 +xml_write,1000,0,3200,80564.444,53795 +xml_write,1000,1,3200,79747.933,53795 +xml_write,1000,2,2800,91212.650,53795 +xml_write,1000,3,2900,86951.967,53795 +xml_write,1000,4,3100,80698.861,53795 +xml_write,1000,5,3200,79843.321,53795 +xml_write,1000,6,3200,79917.821,53795 +json_read,1000,0,4200,60239.515,31792 +json_read,1000,1,4200,60263.191,31792 +json_read,1000,2,4300,59441.887,31792 +json_read,1000,3,4300,59431.815,31792 +json_read,1000,4,4200,59710.053,31792 +json_read,1000,5,4200,59894.996,31792 +json_read,1000,6,4200,59610.010,31792 +json_write,1000,0,10000,25118.306,31792 +json_write,1000,1,10500,23931.980,31792 +json_write,1000,2,10000,25004.418,31792 +json_write,1000,3,10500,23930.295,31792 +json_write,1000,4,10400,24052.177,31792 +json_write,1000,5,10000,25117.633,31792 +json_write,1000,6,10400,24115.481,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-1.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-1.csv new file mode 100644 index 0000000..32a4553 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-1.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,771300,324.161,65 +xml_read,1,1,801300,312.026,65 +xml_read,1,2,796400,313.919,65 +xml_read,1,3,786300,317.967,65 +xml_read,1,4,801100,312.077,65 +xml_read,1,5,794000,314.868,65 +xml_read,1,6,791100,316.038,65 +xml_write,1,0,1406200,177.790,65 +xml_write,1,1,1412700,176.972,65 +xml_write,1,2,1410100,177.304,65 +xml_write,1,3,1413500,176.875,65 +xml_write,1,4,1402300,178.283,65 +xml_write,1,5,1414000,176.814,65 +xml_write,1,6,1405200,177.914,65 +json_read,1,0,3092700,80.836,40 +json_read,1,1,3076000,81.274,40 +json_read,1,2,3087100,80.984,40 +json_read,1,3,3083800,81.069,40 +json_read,1,4,3107400,80.454,40 +json_read,1,5,3097700,80.707,40 +json_read,1,6,3082500,81.105,40 +json_write,1,0,6873800,36.370,40 +json_write,1,1,6613000,37.804,40 +json_write,1,2,6692200,37.357,40 +json_write,1,3,6810500,36.708,40 +json_write,1,4,6908300,36.188,40 +json_write,1,5,6892000,36.274,40 +json_write,1,6,6880500,36.335,40 +xml_read,1000,0,1100,238100.315,53795 +xml_read,1000,1,1100,232541.835,53795 +xml_read,1000,2,1100,232604.755,53795 +xml_read,1000,3,1100,234355.271,53795 +xml_read,1000,4,1100,234814.422,53795 +xml_read,1000,5,1100,232705.448,53795 +xml_read,1000,6,1100,232471.955,53795 +xml_write,1000,0,3100,81620.132,53795 +xml_write,1000,1,3200,80398.776,53795 +xml_write,1000,2,3200,79741.282,53795 +xml_write,1000,3,3200,79630.319,53795 +xml_write,1000,4,3100,80725.415,53795 +xml_write,1000,5,3100,82774.011,53795 +xml_write,1000,6,3100,81965.306,53795 +json_read,1000,0,4100,61990.718,31792 +json_read,1000,1,4200,60626.126,31792 +json_read,1000,2,4200,59562.836,31792 +json_read,1000,3,4000,63250.537,31792 +json_read,1000,4,4300,59292.662,31792 +json_read,1000,5,4200,60442.482,31792 +json_read,1000,6,4300,59141.852,31792 +json_write,1000,0,10300,24326.595,31792 +json_write,1000,1,10300,24314.244,31792 +json_write,1000,2,10100,24909.965,31792 +json_write,1000,3,10300,24402.426,31792 +json_write,1000,4,10400,24232.984,31792 +json_write,1000,5,10400,24212.595,31792 +json_write,1000,6,10300,24403.031,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-2.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-2.csv new file mode 100644 index 0000000..f436f54 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-2.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,769700,324.803,65 +xml_read,1,1,797100,313.654,65 +xml_read,1,2,771600,324.025,65 +xml_read,1,3,804900,310.614,65 +xml_read,1,4,720900,346.826,65 +xml_read,1,5,800800,312.217,65 +xml_read,1,6,779700,320.649,65 +xml_write,1,0,1411000,177.185,65 +xml_write,1,1,1386100,180.363,65 +xml_write,1,2,1392900,179.483,65 +xml_write,1,3,1405500,177.875,65 +xml_write,1,4,1408700,177.479,65 +xml_write,1,5,1372300,182.186,65 +xml_write,1,6,1404000,178.069,65 +json_read,1,0,3094500,80.789,40 +json_read,1,1,3132000,79.822,40 +json_read,1,2,3122200,80.074,40 +json_read,1,3,3100700,80.629,40 +json_read,1,4,3120500,80.116,40 +json_read,1,5,3132100,79.819,40 +json_read,1,6,3109500,80.400,40 +json_write,1,0,6884300,36.315,40 +json_write,1,1,6859500,36.446,40 +json_write,1,2,6899900,36.233,40 +json_write,1,3,6745800,37.060,40 +json_write,1,4,6840400,36.548,40 +json_write,1,5,6830200,36.603,40 +json_write,1,6,6745200,37.064,40 +xml_read,1000,0,1100,235116.396,53795 +xml_read,1000,1,1100,231260.446,53795 +xml_read,1000,2,1100,231988.988,53795 +xml_read,1000,3,1100,230769.071,53795 +xml_read,1000,4,1100,233747.427,53795 +xml_read,1000,5,1100,235614.688,53795 +xml_read,1000,6,1100,238330.470,53795 +xml_write,1000,0,3200,79892.218,53795 +xml_write,1000,1,3100,80646.540,53795 +xml_write,1000,2,2900,87476.088,53795 +xml_write,1000,3,3000,83749.795,53795 +xml_write,1000,4,3100,80871.235,53795 +xml_write,1000,5,3200,80385.280,53795 +xml_write,1000,6,3100,81833.489,53795 +json_read,1000,0,4300,59478.399,31792 +json_read,1000,1,4300,59136.712,31792 +json_read,1000,2,4100,61044.084,31792 +json_read,1000,3,4300,59252.316,31792 +json_read,1000,4,4200,59938.303,31792 +json_read,1000,5,4300,59031.757,31792 +json_read,1000,6,4300,59433.747,31792 +json_write,1000,0,10400,24240.645,31792 +json_write,1000,1,10500,24022.514,31792 +json_write,1000,2,10500,23910.609,31792 +json_write,1000,3,10400,24085.161,31792 +json_write,1000,4,10400,24083.207,31792 +json_write,1000,5,10100,24891.708,31792 +json_write,1000,6,10400,24115.996,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-3.csv b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-3.csv new file mode 100644 index 0000000..4fdf968 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-3.csv @@ -0,0 +1,57 @@ +operation,count,repeat,iterations,ns_per_op,bytes +xml_read,1,0,795900,314.142,65 +xml_read,1,1,797800,313.373,65 +xml_read,1,2,799200,312.826,65 +xml_read,1,3,801900,311.780,65 +xml_read,1,4,781800,319.792,65 +xml_read,1,5,740800,337.495,65 +xml_read,1,6,786400,317.929,65 +xml_write,1,0,1394000,179.345,65 +xml_write,1,1,1280600,195.230,65 +xml_write,1,2,1386700,180.287,65 +xml_write,1,3,1354800,184.542,65 +xml_write,1,4,1412000,177.056,65 +xml_write,1,5,1397400,178.910,65 +xml_write,1,6,1411800,177.081,65 +json_read,1,0,3106500,80.478,40 +json_read,1,1,3096800,80.733,40 +json_read,1,2,3066300,81.532,40 +json_read,1,3,3111400,80.352,40 +json_read,1,4,3093500,80.816,40 +json_read,1,5,3094700,80.784,40 +json_read,1,6,3091700,80.863,40 +json_write,1,0,6593700,37.915,40 +json_write,1,1,6667500,37.495,40 +json_write,1,2,6780400,36.871,40 +json_write,1,3,6746300,37.058,40 +json_write,1,4,6849800,36.498,40 +json_write,1,5,6851500,36.488,40 +json_write,1,6,6909800,36.181,40 +xml_read,1000,0,1100,240464.105,53795 +xml_read,1000,1,1100,235349.094,53795 +xml_read,1000,2,1100,235796.017,53795 +xml_read,1000,3,1100,244295.601,53795 +xml_read,1000,4,1100,235124.186,53795 +xml_read,1000,5,1100,233037.098,53795 +xml_read,1000,6,1100,231901.484,53795 +xml_write,1000,0,3200,79968.575,53795 +xml_write,1000,1,3200,80231.527,53795 +xml_write,1000,2,3200,80191.595,53795 +xml_write,1000,3,3200,80127.517,53795 +xml_write,1000,4,3200,80284.771,53795 +xml_write,1000,5,3100,80706.990,53795 +xml_write,1000,6,3100,80801.672,53795 +json_read,1000,0,4200,59535.276,31792 +json_read,1000,1,4100,61196.215,31792 +json_read,1000,2,3900,64570.246,31792 +json_read,1000,3,4200,60283.326,31792 +json_read,1000,4,4300,59286.441,31792 +json_read,1000,5,4300,59446.377,31792 +json_read,1000,6,4300,59383.528,31792 +json_write,1000,0,10500,23837.193,31792 +json_write,1000,1,10500,23874.949,31792 +json_write,1000,2,10500,23842.879,31792 +json_write,1000,3,10500,23932.471,31792 +json_write,1000,4,10300,24284.773,31792 +json_write,1000,5,10500,23938.661,31792 +json_write,1000,6,10500,23909.484,31792 diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-batch.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-batch.rs new file mode 100644 index 0000000..1b02437 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned-batch.rs @@ -0,0 +1,297 @@ +// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML) +#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)] + +use std::borrow::Cow; +use serde::{Deserialize, Serialize}; +use std::str::FromStr; +use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; +use quick_xml::{Reader, Writer}; +use polyxml::{PolyXmlError, Result}; + +#[allow(dead_code)] +pub(crate) fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> { + let mut depth = 1; + loop { + match reader.read_event()? { + Event::Start(_) => depth += 1, + Event::End(_) => { + depth -= 1; + if depth == 0 { + break; + } + } + Event::Eof => break, + _ => {} + } + } + Ok(()) +} + +#[allow(dead_code)] +pub(crate) fn read_element_text(reader: &mut Reader<&[u8]>, tag_name: &str) -> Result { + let mut text = String::new(); + loop { + match reader.read_event()? { + Event::Text(t) => { + let unescaped = quick_xml::escape::unescape(t.as_ref())?; + text.push_str(&unescaped); + } + Event::CData(c) => { + text.push_str(c.as_ref()); + } + Event::GeneralRef(r) => { + if r.is_char_ref() { + if let Some(ch) = r.resolve_char_ref()? { + text.push(ch); + } + } else if let Some(val) = quick_xml::escape::resolve_xml_entity(r.as_ref()) { + text.push_str(val); + } else { + text.push_str(r.as_ref()); + } + } + Event::End(e) if e.local_name().as_ref() == tag_name => break, + Event::Eof => break, + _ => {} + } + } + Ok(text) +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct BatchType { + #[serde(rename = "Sensor", default, skip_serializing_if = "Vec::is_empty")] + pub sensor: Vec, +} + +impl BatchType { + pub fn from_xml(xml: &str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing BatchType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &[u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'_ [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_sensor = Vec::new(); + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml(reader, &e)?; + var_sensor.push(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Sensor" => { + let val = SensorType::decode_xml_empty(&e)?; + var_sensor.push(val); + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let var_sensor = Vec::new(); + + Ok(Self { + sensor: var_sensor, + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &[u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("BatchType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + for item in &self.sensor { + item.encode_xml(writer, Some("Sensor"))?; + } + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct SensorType { + #[serde(rename = "Id")] + pub id: String, + #[serde(rename = "Value")] + pub value: i32, +} + +impl SensorType { + pub fn from_xml(xml: &str) -> Result + { + let mut reader = Reader::from_str(xml); + loop { + match reader.read_event()? { + Event::Start(e) => return Self::decode_xml(&mut reader, &e), + Event::Empty(e) => return Self::decode_xml_empty(&e), + Event::Eof => break, + _ => {} + } + } + Err(PolyXmlError::SchemaError("Unexpected EOF while parsing SensorType".into())) + } + + pub fn from_xml_bytes(xml_bytes: &[u8]) -> Result + { + let s = std::str::from_utf8(xml_bytes)?; + Self::from_xml(s) + } + + pub fn decode_xml(reader: &mut Reader<&'_ [u8]>, start: &BytesStart<'_>) -> Result + { + let mut var_id = None; + let mut var_value = None; + + loop { + match reader.read_event()? { + Event::Start(e) => match e.local_name().as_ref() { + "Id" => { + let text = read_element_text(reader, "Id")?; + var_id = Some(text); + } + "Value" => { + let text = read_element_text(reader, "Value")?; + let s = text.trim(); + let val = s.parse::().map_err(|_| PolyXmlError::ScalarParseError { field: "value".into(), expected: "i32", value: s.into() })?; + var_value = Some(val); + } + _ => { + skip_xml_element(reader)?; + } + }, + Event::Empty(e) => match e.local_name().as_ref() { + "Id" => { + var_id = Some(String::new()); + } + "Value" => { + } + _ => {} + }, + Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break, + Event::Eof => break, + _ => {} + } + } + + Ok(Self { + id: var_id.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Id'".into()))?, + value: var_value.ok_or_else(|| PolyXmlError::SchemaError("Missing required field 'Value'".into()))?, + }) + } + + pub fn decode_xml_empty(start: &BytesStart<'_>) -> Result { + let mut var_id = None; + let mut var_value = None; + + Ok(Self { + id: var_id.unwrap_or_default(), + value: var_value.unwrap_or_default(), + }) + } + + pub fn to_xml(&self) -> Result> { + let mut buf = Vec::new(); + let mut writer = Writer::new(std::io::Cursor::new(&mut buf)); + self.encode_xml(&mut writer, None)?; + Ok(buf) + } + + pub fn to_xml_string(&self) -> Result { + let bytes = self.to_xml()?; + String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error())) + } + + pub fn from_json_str(json_str: &str) -> std::result::Result + { + serde_json::from_str(json_str) + } + + pub fn from_json_slice(bytes: &[u8]) -> std::result::Result + { + serde_json::from_slice(bytes) + } + + pub fn to_json_string(&self) -> std::result::Result { + serde_json::to_string(self) + } + + pub fn to_json_vec(&self) -> std::result::Result, serde_json::Error> { + serde_json::to_vec(self) + } + + pub fn encode_xml(&self, writer: &mut Writer, tag_name: Option<&str>) -> Result<()> { + let tag = tag_name.unwrap_or("SensorType"); + let mut start = BytesStart::new(tag); + writer.write_event(Event::Start(start))?; + writer.write_event(Event::Start(BytesStart::new("Id")))?; + writer.write_event(Event::Text(BytesText::new(self.id.as_ref())))?; + writer.write_event(Event::End(BytesEnd::new("Id")))?; + writer.write_event(Event::Start(BytesStart::new("Value")))?; + writer.write_event(Event::Text(BytesText::new(&self.value.to_string())))?; + writer.write_event(Event::End(BytesEnd::new("Value")))?; + writer.write_event(Event::End(BytesEnd::new(tag)))?; + Ok(()) + } +} + +pub type Batch = BatchType; diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned.lock new file mode 100644 index 0000000..f8e578e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/current-owned.lock @@ -0,0 +1,320 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "xml-regression" +version = "0.0.0" +dependencies = [ + "polyxml", + "quick-xml", + "serde", + "serde_json", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/harness.rs new file mode 100644 index 0000000..b8a10eb --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/harness.rs @@ -0,0 +1,83 @@ +use std::{ + hint::black_box, + time::{Duration, Instant}, +}; +mod batch; + +fn measure(mut f: impl FnMut(), operation: &str, count: usize, bytes: usize) { + for _ in 0..100 { + f(); + } + for repeat in 0..7 { + let start = Instant::now(); + let mut iterations = 0; + while start.elapsed() < Duration::from_millis(250) { + for _ in 0..100 { + f(); + } + iterations += 100; + } + println!( + "{operation},{count},{repeat},{iterations},{:.3},{bytes}", + start.elapsed().as_nanos() as f64 / iterations as f64 + ); + } +} +fn check(value: &batch::BatchType<'_>, count: usize) { + assert_eq!(value.sensor.len(), count); + for (i, sensor) in value.sensor.iter().enumerate() { + assert_eq!(sensor.id, format!("sensor-{i}")); + assert_eq!(sensor.value, i as i32); + } +} +fn main() { + let fixtures = std::env::args().nth(1).expect("fixture directory"); + println!("operation,count,repeat,iterations,ns_per_op,bytes"); + for count in [1, 1000] { + let xml = std::fs::read_to_string(format!("{fixtures}/sensor-{count}.xml")).unwrap(); + let parsed = batch::BatchType::from_xml(&xml).unwrap(); + check(&parsed, count); + let mut writer = quick_xml::Writer::new(Vec::new()); + parsed.encode_xml(&mut writer, Some("Batch")).unwrap(); + let output = writer.into_inner(); + check(&batch::BatchType::from_xml_bytes(&output).unwrap(), count); + let json = serde_json::to_string(&parsed).unwrap(); + check(&serde_json::from_str(&json).unwrap(), count); + measure( + || { + black_box(batch::BatchType::from_xml(black_box(&xml)).unwrap()); + }, + "xml_read", + count, + xml.len(), + ); + measure( + || { + let mut writer = quick_xml::Writer::new(Vec::new()); + black_box(&parsed) + .encode_xml(&mut writer, Some("Batch")) + .unwrap(); + black_box(writer.into_inner()); + }, + "xml_write", + count, + output.len(), + ); + measure( + || { + black_box(serde_json::from_str::>(black_box(&json)).unwrap()); + }, + "json_read", + count, + json.len(), + ); + measure( + || { + black_box(serde_json::to_vec(black_box(&parsed)).unwrap()); + }, + "json_write", + count, + json.len(), + ); + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/metadata.json new file mode 100644 index 0000000..98710ca --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/metadata.json @@ -0,0 +1,12 @@ +{ + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "cpu": "11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz", + "rounds": 4, + "warmup": "100 operations per operation/size", + "samples": "7 x >=250ms per operation/size/process", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n", + "revisions": { + "baseline": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "current": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d" + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/summary.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/summary.json new file mode 100644 index 0000000..1c38ead --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-generated/summary.json @@ -0,0 +1,434 @@ +{ + "borrowed/json_read/1": { + "baseline_ns": 82.0875, + "candidate_ns": 80.2955, + "delta_percent": -2.1830363940916753, + "speedup": 1.0223175644961424, + "process_values_ns": { + "baseline": [ + 82.388, + 81.75, + 81.787, + 83.282 + ], + "current": [ + 80.158, + 80.433, + 81.54, + 80.054 + ] + }, + "process_deltas_percent": [ + -2.706704859931064, + -1.611009174311917, + -0.3020039859635393, + -3.875987608366749 + ], + "statistic": "median across process sample medians" + }, + "borrowed/json_read/1000": { + "baseline_ns": 60323.093, + "candidate_ns": 58903.306, + "delta_percent": -2.3536376027668227, + "speedup": 1.0241036895280546, + "process_values_ns": { + "baseline": [ + 60521.405, + 60243.156, + 60379.292, + 60266.894 + ], + "current": [ + 59175.735, + 58710.255, + 59093.242, + 58713.37 + ] + }, + "process_deltas_percent": [ + -2.2234612696119593, + -2.5445230658234563, + -2.129952103446331, + -2.577740276444307 + ], + "statistic": "median across process sample medians" + }, + "borrowed/json_write/1": { + "baseline_ns": 38.256, + "candidate_ns": 40.339, + "delta_percent": 5.444897532413218, + "speedup": 0.9483626267383921, + "process_values_ns": { + "baseline": [ + 38.695, + 38.357, + 38.117, + 38.155 + ], + "current": [ + 39.522, + 38.916, + 41.471, + 41.156 + ] + }, + "process_deltas_percent": [ + 2.1372270319162556, + 1.4573611074901516, + 8.79922344360784, + 7.865286332066557 + ], + "statistic": "median across process sample medians" + }, + "borrowed/json_write/1000": { + "baseline_ns": 25663.8825, + "candidate_ns": 25978.036, + "delta_percent": 1.2241074591889944, + "speedup": 0.9879069572464986, + "process_values_ns": { + "baseline": [ + 25663.313, + 25940.777, + 25664.452, + 25449.99 + ], + "current": [ + 26074.351, + 25881.721, + 25814.005, + 26876.503 + ] + }, + "process_deltas_percent": [ + 1.6016560293676818, + -0.22765702045084435, + 0.5827243067570764, + 5.60516133798088 + ], + "statistic": "median across process sample medians" + }, + "borrowed/xml_read/1": { + "baseline_ns": 300.03499999999997, + "candidate_ns": 287.2505, + "delta_percent": -4.261002882996978, + "speedup": 1.0445064499452568, + "process_values_ns": { + "baseline": [ + 300.385, + 302.046, + 299.685, + 299.655 + ], + "current": [ + 288.124, + 286.22, + 287.372, + 287.129 + ] + }, + "process_deltas_percent": [ + -4.081761739101475, + -5.239599266336903, + -4.108647413117106, + -4.180140494902451 + ], + "statistic": "median across process sample medians" + }, + "borrowed/xml_read/1000": { + "baseline_ns": 194653.6715, + "candidate_ns": 185728.8035, + "delta_percent": -4.584998541884677, + "speedup": 1.0480532250884822, + "process_values_ns": { + "baseline": [ + 194318.975, + 194988.368, + 193877.262, + 195159.815 + ], + "current": [ + 186515.871, + 185165.041, + 185902.056, + 185555.551 + ] + }, + "process_deltas_percent": [ + -4.015616076608053, + -5.037904107182434, + -4.113533437458994, + -4.921230326027926 + ], + "statistic": "median across process sample medians" + }, + "borrowed/xml_write/1": { + "baseline_ns": 170.83249999999998, + "candidate_ns": 171.236, + "delta_percent": 0.23619627412816424, + "speedup": 0.9976436029806816, + "process_values_ns": { + "baseline": [ + 170.59, + 170.252, + 171.463, + 171.075 + ], + "current": [ + 171.3, + 171.172, + 170.801, + 172.017 + ] + }, + "process_deltas_percent": [ + 0.416202591007675, + 0.5403754434602837, + -0.3860891271003086, + 0.5506356861025852 + ], + "statistic": "median across process sample medians" + }, + "borrowed/xml_write/1000": { + "baseline_ns": 54281.294, + "candidate_ns": 51676.5135, + "delta_percent": -4.79867060648923, + "speedup": 1.0504054999763093, + "process_values_ns": { + "baseline": [ + 54130.73, + 54431.858, + 53872.526, + 55303.228 + ], + "current": [ + 51877.138, + 52925.848, + 51475.889, + 51420.229 + ] + }, + "process_deltas_percent": [ + -4.163239623777482, + -2.766780439499239, + -4.4487184432376425, + -7.0212881606115385 + ], + "statistic": "median across process sample medians" + }, + "owned/json_read/1": { + "baseline_ns": 80.77850000000001, + "candidate_ns": 80.884, + "delta_percent": 0.13060405924842922, + "speedup": 0.9986956629246824, + "process_values_ns": { + "baseline": [ + 80.916, + 80.641, + 82.365, + 80.553 + ], + "current": [ + 81.066, + 80.984, + 80.116, + 80.784 + ] + }, + "process_deltas_percent": [ + 0.18537742844431104, + 0.4253419476444753, + -2.730528744005334, + 0.28676771814830637 + ], + "statistic": "median across process sample medians" + }, + "owned/json_read/1000": { + "baseline_ns": 59245.266, + "candidate_ns": 59622.6645, + "delta_percent": 0.6370103899947077, + "speedup": 0.9936702174724178, + "process_values_ns": { + "baseline": [ + 59379.771, + 59110.761, + 58822.587, + 60303.164 + ], + "current": [ + 59710.053, + 60442.482, + 59433.747, + 59535.276 + ] + }, + "process_deltas_percent": [ + 0.5562197267483526, + 2.2529248100866095, + 1.0389886456370956, + -1.2733792873620975 + ], + "statistic": "median across process sample medians" + }, + "owned/json_write/1": { + "baseline_ns": 36.562, + "candidate_ns": 36.709500000000006, + "delta_percent": 0.40342432033260156, + "speedup": 0.9959819665209276, + "process_values_ns": { + "baseline": [ + 37.024, + 37.253, + 36.093, + 36.1 + ], + "current": [ + 36.929, + 36.37, + 36.548, + 36.871 + ] + }, + "process_deltas_percent": [ + -0.2565903197925601, + -2.370278903712464, + 1.2606322555620109, + 2.1357340720221663 + ], + "statistic": "median across process sample medians" + }, + "owned/json_write/1000": { + "baseline_ns": 24243.841500000002, + "candidate_ns": 24100.321, + "delta_percent": -0.5919874538034886, + "speedup": 1.005955128149538, + "process_values_ns": { + "baseline": [ + 24357.375, + 24288.611, + 23934.693, + 24199.072 + ], + "current": [ + 24115.481, + 24326.595, + 24085.161, + 23909.484 + ] + }, + "process_deltas_percent": [ + -0.9931037314160451, + 0.15638605270593686, + 0.6286606642500026, + -1.1966905177190235 + ], + "statistic": "median across process sample medians" + }, + "owned/xml_read/1": { + "baseline_ns": 313.3, + "candidate_ns": 314.505, + "delta_percent": 0.38461538461538325, + "speedup": 0.996168582375479, + "process_values_ns": { + "baseline": [ + 312.604, + 313.057, + 314.716, + 313.543 + ], + "current": [ + 312.52, + 314.868, + 320.649, + 314.142 + ] + }, + "process_deltas_percent": [ + -0.0268710573121278, + 0.5784889013821681, + 1.8851917284154585, + 0.1910423769626357 + ], + "statistic": "median across process sample medians" + }, + "owned/xml_read/1000": { + "baseline_ns": 234470.7775, + "candidate_ns": 233462.641, + "delta_percent": -0.4299625355232095, + "speedup": 1.0043181919628845, + "process_values_ns": { + "baseline": [ + 234370.285, + 234375.853, + 234565.702, + 238183.975 + ], + "current": [ + 233177.855, + 232705.448, + 233747.427, + 235349.094 + ] + }, + "process_deltas_percent": [ + -0.5087803686375958, + -0.7127035394725589, + -0.34884682330923455, + -1.190206436012331 + ], + "statistic": "median across process sample medians" + }, + "owned/xml_write/1": { + "baseline_ns": 174.954, + "candidate_ns": 178.707, + "delta_percent": 2.1451352927055023, + "speedup": 0.9789991438499892, + "process_values_ns": { + "baseline": [ + 175.216, + 174.784, + 173.729, + 175.124 + ], + "current": [ + 179.891, + 177.304, + 178.069, + 179.345 + ] + }, + "process_deltas_percent": [ + 2.6681353301068356, + 1.4417795679238399, + 2.49814366052874, + 2.4102921358580165 + ], + "statistic": "median across process sample medians" + }, + "owned/xml_write/1000": { + "baseline_ns": 80084.0135, + "candidate_ns": 80644.9295, + "delta_percent": 0.7004094518814341, + "speedup": 0.9930446216088514, + "process_values_ns": { + "baseline": [ + 81013.157, + 80084.668, + 80083.359, + 80079.414 + ], + "current": [ + 80564.444, + 80725.415, + 80871.235, + 80231.527 + ] + }, + "process_deltas_percent": [ + -0.5538766993119393, + 0.8000869779468678, + 0.9838198719911428, + 0.18995268871473403 + ], + "statistic": "median across process sample medians" + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-0.txt new file mode 100644 index 0000000..7da9f72 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-0.txt @@ -0,0 +1,63 @@ +memcap: <=7823 MiB (60% of 13039 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0041 s (5.1M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [967.40 ns 970.10 ns 973.00 ns] + thrpt: [92.133 MiB/s 92.409 MiB/s 92.667 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.5721 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [750.25 µs 754.31 µs 759.36 µs] + thrpt: [80.265 MiB/s 80.803 MiB/s 81.240 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 6 (6.00%) high mild + 7 (7.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.2733 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.5513 ms 7.5858 ms 7.6329 ms] + thrpt: [83.576 MiB/s 84.094 MiB/s 84.479 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 5 (5.00%) high mild + 6 (6.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0005 s (19M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [254.07 ns 256.75 ns 259.97 ns] + thrpt: [344.83 MiB/s 349.15 MiB/s 352.84 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 3 (3.00%) high mild + 10 (10.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.0710 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [199.25 µs 200.60 µs 202.44 µs] + thrpt: [298.73 MiB/s 301.47 MiB/s 303.50 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.1982 s (2600 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.9969 ms 2.0052 ms 2.0148 ms] + thrpt: [314.25 MiB/s 315.76 MiB/s 317.07 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 2 (2.00%) high mild + 6 (6.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-1.txt new file mode 100644 index 0000000..168cb5b --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-1.txt @@ -0,0 +1,62 @@ +memcap: <=7884 MiB (60% of 13140 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0000 s (5.2M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [970.14 ns 977.09 ns 985.38 ns] + thrpt: [90.975 MiB/s 91.747 MiB/s 92.405 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 6 (6.00%) high mild + 8 (8.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.6116 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [756.38 µs 759.54 µs 763.34 µs] + thrpt: [79.847 MiB/s 80.246 MiB/s 80.581 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 2 (2.00%) high mild + 7 (7.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.3057 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.5587 ms 7.5976 ms 7.6481 ms] + thrpt: [83.409 MiB/s 83.964 MiB/s 84.395 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0008 s (20M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [258.02 ns 261.21 ns 264.65 ns] + thrpt: [338.73 MiB/s 343.19 MiB/s 347.44 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 3 (3.00%) high mild + 8 (8.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.0361 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [199.95 µs 201.71 µs 203.80 µs] + thrpt: [296.73 MiB/s 299.81 MiB/s 302.45 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 4 (4.00%) high mild + 7 (7.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.0071 s (2500 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [2.0021 ms 2.0153 ms 2.0312 ms] + thrpt: [311.71 MiB/s 314.17 MiB/s 316.25 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 10 (10.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-2.txt new file mode 100644 index 0000000..f145595 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-2.txt @@ -0,0 +1,63 @@ +memcap: <=7884 MiB (60% of 13140 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0035 s (5.2M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [969.13 ns 975.20 ns 982.03 ns] + thrpt: [91.286 MiB/s 91.925 MiB/s 92.501 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 5 (5.00%) high mild + 7 (7.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.7410 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [749.08 µs 751.55 µs 754.33 µs] + thrpt: [80.801 MiB/s 81.099 MiB/s 81.366 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 4 (4.00%) high mild + 5 (5.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.2995 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.5232 ms 7.5637 ms 7.6225 ms] + thrpt: [83.689 MiB/s 84.340 MiB/s 84.794 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0010 s (20M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [254.09 ns 255.22 ns 256.62 ns] + thrpt: [349.33 MiB/s 351.24 MiB/s 352.81 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 3 (3.00%) high mild + 6 (6.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.1711 s (25k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [199.61 µs 201.24 µs 203.19 µs] + thrpt: [297.62 MiB/s 300.51 MiB/s 302.96 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 5.0033 s (2500 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.9968 ms 2.0030 ms 2.0107 ms] + thrpt: [314.89 MiB/s 316.10 MiB/s 317.09 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 6 (6.00%) high mild + 4 (4.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-build.txt new file mode 100644 index 0000000..bdbf276 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline-build.txt @@ -0,0 +1,5 @@ +memcap: <=7882 MiB (60% of 13138 MiB available) [systemd MemoryMax, swap off] + Locking 1 package to highest compatible version + Downgrading polyxml v0.34.6 (/home/bailey/github/polyxml-perf-old/crates/polyxml-core) -> v0.27.0 + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-baseline) + Finished `bench` profile [optimized] target(s) in 2.42s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline.lock new file mode 100644 index 0000000..f6f0de7 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/baseline.lock @@ -0,0 +1,632 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.27.0" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-0.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-0.txt new file mode 100644 index 0000000..157de27 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-0.txt @@ -0,0 +1,64 @@ +memcap: <=7881 MiB (60% of 13136 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0048 s (4.9M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0017 µs 1.0065 µs 1.0121 µs] + thrpt: [88.571 MiB/s 89.068 MiB/s 89.493 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 4 (4.00%) high mild + 10 (10.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.9521 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [787.64 µs 796.62 µs 810.19 µs] + thrpt: [75.230 MiB/s 76.511 MiB/s 77.383 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 5 (5.00%) high mild + 10 (10.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5068 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.8462 ms 7.9085 ms 7.9850 ms] + thrpt: [79.890 MiB/s 80.663 MiB/s 81.304 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 9 (9.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0003 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [226.75 ns 227.46 ns 228.26 ns] + thrpt: [392.74 MiB/s 394.11 MiB/s 395.34 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 8 (8.00%) high mild + 4 (4.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.4158 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [178.53 µs 180.08 µs 182.06 µs] + thrpt: [332.16 MiB/s 335.81 MiB/s 338.73 MiB/s] +Found 17 outliers among 100 measurements (17.00%) + 4 (4.00%) high mild + 13 (13.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.1s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.0778 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.7960 ms 1.8090 ms 1.8249 ms] + thrpt: [346.95 MiB/s 350.00 MiB/s 352.53 MiB/s] +Found 11 outliers among 100 measurements (11.00%) + 6 (6.00%) high mild + 5 (5.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-1.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-1.txt new file mode 100644 index 0000000..f69f7b6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-1.txt @@ -0,0 +1,65 @@ +memcap: <=7886 MiB (60% of 13144 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0027 s (5.0M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0056 µs 1.0178 µs 1.0338 µs] + thrpt: [86.717 MiB/s 88.079 MiB/s 89.148 MiB/s] +Found 10 outliers among 100 measurements (10.00%) + 3 (3.00%) high mild + 7 (7.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 8.0668 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [788.54 µs 791.73 µs 795.39 µs] + thrpt: [76.630 MiB/s 76.984 MiB/s 77.295 MiB/s] +Found 6 outliers among 100 measurements (6.00%) + 3 (3.00%) high mild + 3 (3.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5717 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.9173 ms 7.9997 ms 8.1054 ms] + thrpt: [78.703 MiB/s 79.743 MiB/s 80.573 MiB/s] +Found 16 outliers among 100 measurements (16.00%) + 5 (5.00%) high mild + 11 (11.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0003 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [228.58 ns 230.06 ns 231.71 ns] + thrpt: [386.89 MiB/s 389.67 MiB/s 392.18 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 4 (4.00%) high mild + 8 (8.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.5305 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [179.32 µs 180.96 µs 182.99 µs] + thrpt: [330.47 MiB/s 334.18 MiB/s 337.24 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 5 (5.00%) high mild + 7 (7.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.1s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.1460 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.8047 ms 1.8166 ms 1.8299 ms] + thrpt: [346.01 MiB/s 348.54 MiB/s 350.84 MiB/s] +Found 12 outliers among 100 measurements (12.00%) + 6 (6.00%) high mild + 6 (6.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-2.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-2.txt new file mode 100644 index 0000000..22b809e --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-2.txt @@ -0,0 +1,65 @@ +memcap: <=7882 MiB (60% of 13138 MiB available) [systemd MemoryMax, swap off] +Benchmarking deserialization/sensor_micro +Benchmarking deserialization/sensor_micro: Warming up for 3.0000 s +Benchmarking deserialization/sensor_micro: Collecting 100 samples in estimated 5.0025 s (4.9M iterations) +Benchmarking deserialization/sensor_micro: Analyzing +deserialization/sensor_micro + time: [1.0006 µs 1.0036 µs 1.0072 µs] + thrpt: [89.006 MiB/s 89.323 MiB/s 89.594 MiB/s] +Found 7 outliers among 100 measurements (7.00%) + 3 (3.00%) high mild + 4 (4.00%) high severe +Benchmarking deserialization/catalog_items/1000 +Benchmarking deserialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/1000: Collecting 100 samples in estimated 7.9756 s (10k iterations) +Benchmarking deserialization/catalog_items/1000: Analyzing +deserialization/catalog_items/1000 + time: [786.84 µs 791.45 µs 797.22 µs] + thrpt: [76.454 MiB/s 77.011 MiB/s 77.462 MiB/s] +Found 14 outliers among 100 measurements (14.00%) + 5 (5.00%) high mild + 9 (9.00%) high severe +Benchmarking deserialization/catalog_items/10000 +Benchmarking deserialization/catalog_items/10000: Warming up for 3.0000 s +Benchmarking deserialization/catalog_items/10000: Collecting 100 samples in estimated 5.5093 s (700 iterations) +Benchmarking deserialization/catalog_items/10000: Analyzing +deserialization/catalog_items/10000 + time: [7.8827 ms 7.9640 ms 8.0628 ms] + thrpt: [79.120 MiB/s 80.101 MiB/s 80.927 MiB/s] +Found 13 outliers among 100 measurements (13.00%) + 2 (2.00%) high mild + 11 (11.00%) high severe + +Benchmarking serialization/sensor_micro +Benchmarking serialization/sensor_micro: Warming up for 3.0000 s +Benchmarking serialization/sensor_micro: Collecting 100 samples in estimated 5.0001 s (22M iterations) +Benchmarking serialization/sensor_micro: Analyzing +serialization/sensor_micro + time: [227.05 ns 228.26 ns 230.09 ns] + thrpt: [389.61 MiB/s 392.74 MiB/s 394.83 MiB/s] +Found 15 outliers among 100 measurements (15.00%) + 2 (2.00%) high mild + 13 (13.00%) high severe +Benchmarking serialization/catalog_items/1000 +Benchmarking serialization/catalog_items/1000: Warming up for 3.0000 s +Benchmarking serialization/catalog_items/1000: Collecting 100 samples in estimated 5.4033 s (30k iterations) +Benchmarking serialization/catalog_items/1000: Analyzing +serialization/catalog_items/1000 + time: [176.99 µs 177.82 µs 179.08 µs] + thrpt: [337.68 MiB/s 340.08 MiB/s 341.68 MiB/s] +Found 8 outliers among 100 measurements (8.00%) + 3 (3.00%) high mild + 5 (5.00%) high severe +Benchmarking serialization/catalog_items/10000 +Benchmarking serialization/catalog_items/10000: Warming up for 3.0000 s + +Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 9.1s, enable flat sampling, or reduce sample count to 50. +Benchmarking serialization/catalog_items/10000: Collecting 100 samples in estimated 9.0583 s (5050 iterations) +Benchmarking serialization/catalog_items/10000: Analyzing +serialization/catalog_items/10000 + time: [1.7941 ms 1.8015 ms 1.8101 ms] + thrpt: [349.80 MiB/s 351.46 MiB/s 352.90 MiB/s] +Found 9 outliers among 100 measurements (9.00%) + 5 (5.00%) high mild + 4 (4.00%) high severe + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-build.txt new file mode 100644 index 0000000..9cae711 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current-build.txt @@ -0,0 +1,5 @@ +memcap: <=7858 MiB (60% of 13097 MiB available) [systemd MemoryMax, swap off] + Locking 1 package to highest compatible version + Updating polyxml v0.27.0 (/home/bailey/github/PolyXML/crates/polyxml-core) -> v0.34.6 + Compiling core-regression v0.0.0 (/home/bailey/github/PolyXML/benchmarks/rust-xml-regression/target/core-current) + Finished `bench` profile [optimized] target(s) in 2.55s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current.lock b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current.lock new file mode 100644 index 0000000..78a11b2 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/current.lock @@ -0,0 +1,633 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "core-regression" +version = "0.0.0" +dependencies = [ + "criterion", + "polyxml", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools", + "num-traits", + "oorandom", + "page_size", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memo-map" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5449c8c750f1a07ea702bbd212bd999fceece9b3d1508b17023b3e174583124b" + +[[package]] +name = "minijinja" +version = "2.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86886cf6dbf4e614b19c9a1eec9775f021869d7eadde0fc73921a81b90c9b4c9" +dependencies = [ + "memo-map", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "phf_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b585a510fb76fdebead6897982ef2a03a21d8e6cbcca904999742a4afc6ffe" +dependencies = [ + "phf_generator", + "phf_shared", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "polyxml" +version = "0.34.6" +dependencies = [ + "heck", + "lexical-core", + "memchr", + "minijinja", + "phf_codegen", + "quick-xml", + "regex", + "serde", + "serde_json", + "smallvec", + "thiserror", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/harness.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/harness.rs new file mode 100644 index 0000000..073ad98 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/harness.rs @@ -0,0 +1,172 @@ +use std::hint::black_box; + +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput}; +use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType}; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn build_sensor_fixture() -> (Arc, Vec) { + let schema = ModelSchema::builder("Sensor") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "temp", + b"temp", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .field(FieldSchema::new( + "status", + b"status", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "active", + b"active", + FieldKind::Element, + ValueType::Scalar(ScalarType::Bool), + )) + .build(); + + let xml = br#"23.75OPERATIONALtrue"#.to_vec(); + let value = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let output = serialize("Sensor", &value, &schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&schema)).unwrap()); + (schema, xml) +} + +fn build_catalog_fixture(count: usize) -> (Arc, Vec) { + let item_schema = ModelSchema::builder("Item") + .field(FieldSchema::new( + "id", + b"id", + FieldKind::Attribute, + ValueType::Scalar(ScalarType::Int), + )) + .field(FieldSchema::new( + "name", + b"name", + FieldKind::Element, + ValueType::Scalar(ScalarType::String), + )) + .field(FieldSchema::new( + "price", + b"price", + FieldKind::Element, + ValueType::Scalar(ScalarType::Float), + )) + .build(); + + let catalog_schema = ModelSchema::builder("Catalog") + .field(FieldSchema::new( + "items", + b"item", + FieldKind::Element, + ValueType::List(Box::new(ValueType::Nested(item_schema))), + )) + .build(); + + let mut xml = String::with_capacity(count * 64 + 32); + xml.push_str(""); + for i in 0..count { + use std::fmt::Write; + write!( + xml, + r#"Part-{i}{:.2}"#, + (i as f64) * 1.25 + ) + .unwrap(); + } + xml.push_str(""); + + let xml = xml.into_bytes(); + let value = deserialize(&xml, Arc::clone(&catalog_schema)).unwrap(); + assert_eq!(value.get("items").unwrap().as_list().unwrap().len(), count); + let output = serialize("Catalog", &value, &catalog_schema, None).unwrap(); + assert_eq!(value, deserialize(&output, Arc::clone(&catalog_schema)).unwrap()); + (catalog_schema, xml) +} + +fn bench_deserialization(c: &mut Criterion) { + let mut group = c.benchmark_group("deserialization"); + + // 1. Sensor Telemetry (Micro) + { + let (schema, xml) = build_sensor_fixture(); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_function("sensor_micro", |b| { + b.iter(|| { + let res = deserialize(black_box(&xml), Arc::clone(&schema)).unwrap(); + black_box(res); + }); + }); + } + + // 2. Catalog Batch (1,000 and 10,000 items) + for &count in &[1_000, 10_000] { + let (schema, xml) = build_catalog_fixture(count); + group.throughput(Throughput::Bytes(xml.len() as u64)); + group.bench_with_input(BenchmarkId::new("catalog_items", count), &count, |b, _| { + b.iter(|| { + let res = deserialize(black_box(&xml), Arc::clone(&schema)).unwrap(); + black_box(res); + }); + }); + } + + group.finish(); +} + +fn bench_serialization(c: &mut Criterion) { + let mut group = c.benchmark_group("serialization"); + + // 1. Sensor Telemetry (Micro) + { + let (schema, xml) = build_sensor_fixture(); + let val = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let expected_bytes = serialize("Sensor", &val, &schema, None).unwrap(); + group.throughput(Throughput::Bytes(expected_bytes.len() as u64)); + group.bench_function("sensor_micro", |b| { + b.iter(|| { + let res = serialize( + black_box("Sensor"), + black_box(&val), + black_box(&schema), + black_box(None), + ) + .unwrap(); + black_box(res); + }); + }); + } + + // 2. Catalog Batch (1,000 and 10,000 items) + for &count in &[1_000, 10_000] { + let (schema, xml) = build_catalog_fixture(count); + let val = deserialize(&xml, Arc::clone(&schema)).unwrap(); + let expected_bytes = serialize("Catalog", &val, &schema, None).unwrap(); + group.throughput(Throughput::Bytes(expected_bytes.len() as u64)); + group.bench_with_input(BenchmarkId::new("catalog_items", count), &count, |b, _| { + b.iter(|| { + let res = serialize( + black_box("Catalog"), + black_box(&val), + black_box(&schema), + black_box(None), + ) + .unwrap(); + black_box(res); + }); + }); + } + + group.finish(); +} + +criterion_group!(benches, bench_deserialization, bench_serialization); +criterion_main!(benches); diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/metadata.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/metadata.json new file mode 100644 index 0000000..1b8ca4f --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/metadata.json @@ -0,0 +1,19 @@ +{ + "revisions": { + "baseline": "cef575c11cc4f05e877ced157036f7ff53b8687b", + "current": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d" + }, + "core_status": { + "baseline": "", + "current": "" + }, + "sample_size": 100, + "warmup_seconds": 3.0, + "measurement_seconds": 5.0, + "rounds": 3, + "filter": "", + "order": "alternate baseline/current per round", + "os": "Linux-6.18.40.1-microsoft-standard-WSL2-x86_64-with-glibc2.43", + "cpu": "11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)\nbinary: rustc\ncommit-hash: b940084d7eb6a299eb4bfeb8e34901bc051e7ac4\ncommit-date: 2026-09-28\nhost: x86_64-unknown-linux-gnu\nrelease: 1.99.0\nLLVM version: 23.1.1\n" +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/samples.tar.gz b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/samples.tar.gz new file mode 100644 index 0000000..7fe7069 Binary files /dev/null and b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/samples.tar.gz differ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/summary.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/summary.json new file mode 100644 index 0000000..555a787 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/selected-old-core/summary.json @@ -0,0 +1,428 @@ +{ + "deserialization/catalog_items/1000": { + "baseline_ns": 755808.7261670816, + "candidate_ns": 796211.3548976812, + "delta_percent": 5.345615541579241, + "speedup": 0.9492564022328072, + "process_deltas_percent": [ + 5.594467193414321, + 3.6065644494165605, + 6.1165784665023315 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 751059.9685813023, + "upper_bound": 761975.8548897612 + }, + "point_estimate": 755808.7261670816, + "standard_error": 2820.3855390196068 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 758549.566319238, + "upper_bound": 776327.7329276396 + }, + "point_estimate": 766472.644334814, + "standard_error": 4565.439824159987 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 748456.1339043864, + "upper_bound": 752373.4905254878 + }, + "point_estimate": 750317.5907137075, + "standard_error": 1002.3668647192248 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 790064.0489977621, + "upper_bound": 808060.6892174009 + }, + "point_estimate": 798092.1973974616, + "standard_error": 4631.603017561554 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 789732.1593981027, + "upper_bound": 799873.7957211259 + }, + "point_estimate": 794115.9742398965, + "standard_error": 2619.556857750202 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 789818.5111402059, + "upper_bound": 803442.7635847568 + }, + "point_estimate": 796211.3548976812, + "standard_error": 3483.3826194079265 + } + ] + } + }, + "deserialization/catalog_items/10000": { + "baseline_ns": 7585809.051428573, + "candidate_ns": 7963984.387142858, + "delta_percent": 4.985299961420275, + "speedup": 0.9525143047335936, + "process_deltas_percent": [ + 4.253614394017968, + 5.293356592933907, + 5.291859308921576 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7551282.802821426, + "upper_bound": 7632896.880035716 + }, + "point_estimate": 7585809.051428573, + "standard_error": 21130.27760125623 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7558740.848678572, + "upper_bound": 7648142.352642859 + }, + "point_estimate": 7597574.675714284, + "standard_error": 23021.572643915988 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7523174.550071423, + "upper_bound": 7622518.386571431 + }, + "point_estimate": 7563722.817142858, + "standard_error": 25910.680140789707 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7846185.140642855, + "upper_bound": 7984972.822214286 + }, + "point_estimate": 7908480.117142857, + "standard_error": 35654.39512738086 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7917302.24114285, + "upper_bound": 8105449.03528571 + }, + "point_estimate": 7999741.395714284, + "standard_error": 48362.46164777882 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 7882689.4598571425, + "upper_bound": 8062776.259714285 + }, + "point_estimate": 7963984.387142858, + "standard_error": 46162.60754546384 + } + ] + } + }, + "deserialization/sensor_micro": { + "baseline_ns": 974.5931079555443, + "candidate_ns": 1008.6872212796135, + "delta_percent": 3.4982920611444035, + "speedup": 0.9661995189343059, + "process_deltas_percent": [ + 5.00502406258474, + 3.40040906302983, + 3.070998044895168 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 966.9427337015497, + "upper_bound": 972.3380208309945 + }, + "point_estimate": 969.4997435801841, + "standard_error": 1.3781370877914338 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 970.0514366515218, + "upper_bound": 981.8054024838184 + }, + "point_estimate": 975.5156971040101, + "standard_error": 3.0095437006279875 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 968.3814557819711, + "upper_bound": 982.3283139894055 + }, + "point_estimate": 974.5931079555443, + "standard_error": 3.5865184492605913 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1004.3208878360266, + "upper_bound": 1040.0977061376784 + }, + "point_estimate": 1018.0234390330697, + "standard_error": 9.540220987586187 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1001.9399499517547, + "upper_bound": 1016.8247685896207 + }, + "point_estimate": 1008.6872212796135, + "standard_error": 3.814783182697997 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1000.5024171447257, + "upper_bound": 1009.7945647810004 + }, + "point_estimate": 1004.5228432465422, + "standard_error": 2.3990147097538084 + } + ] + } + }, + "serialization/catalog_items/1000": { + "baseline_ns": 200999.03612275157, + "candidate_ns": 180103.744257011, + "delta_percent": -10.395717446614839, + "speedup": 1.1160180869750416, + "process_deltas_percent": [ + -10.509006451785696, + -10.284951882304217, + -10.663027072983567 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 199418.0066106714, + "upper_bound": 203705.2736815826 + }, + "point_estimate": 201253.48609519913, + "standard_error": 1106.4626522945625 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 199717.77468161745, + "upper_bound": 202037.9410808132 + }, + "point_estimate": 200789.116968908, + "standard_error": 594.3518667466981 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 199665.71147916323, + "upper_bound": 202963.69566423158 + }, + "point_estimate": 200999.03612275157, + "standard_error": 864.2336219078895 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 178755.32357830938, + "upper_bound": 181682.37906752693 + }, + "point_estimate": 180103.744257011, + "standard_error": 750.6729694263631 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 178971.98454715242, + "upper_bound": 181645.9027926965 + }, + "point_estimate": 180138.05290375228, + "standard_error": 690.2502527330136 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 177221.38028230696, + "upper_bound": 183535.6424454281 + }, + "point_estimate": 179566.45448454656, + "standard_error": 1711.9303067379851 + } + ] + } + }, + "serialization/catalog_items/10000": { + "baseline_ns": 2005150.2546153846, + "candidate_ns": 1806557.5171926087, + "delta_percent": -9.904132469158466, + "speedup": 1.1099288207171998, + "process_deltas_percent": [ + -9.887337067224278, + -10.359395250639903, + -10.05221782703054 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1996916.633009615, + "upper_bound": 2014787.5942692317 + }, + "point_estimate": 2005150.2546153846, + "standard_error": 4572.373596833154 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 2002095.4525299992, + "upper_bound": 2031238.4900200001 + }, + "point_estimate": 2015333.9239999994, + "standard_error": 7467.711111009626 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1996777.3562900005, + "upper_bound": 2010723.1871499992 + }, + "point_estimate": 2003037.4420000003, + "standard_error": 3567.372045212245 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1796956.0384374966, + "upper_bound": 1818725.1445633376 + }, + "point_estimate": 1806894.2902372556, + "standard_error": 5571.908267489618 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1798396.1846502726, + "upper_bound": 1815725.360174217 + }, + "point_estimate": 1806557.5171926087, + "standard_error": 4427.66103242796 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 1793691.7290509846, + "upper_bound": 1811325.288422301 + }, + "point_estimate": 1801687.7551731798, + "standard_error": 4536.546032252471 + } + ] + } + }, + "serialization/sensor_micro": { + "baseline_ns": 257.81954823695725, + "candidate_ns": 229.2775440514841, + "delta_percent": -11.07053533397735, + "speedup": 1.1244866971318572, + "process_deltas_percent": [ + -11.864018040490121, + -11.394039785000743, + -8.461418285239898 + ], + "process_estimates": { + "baseline": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 254.7240123110133, + "upper_bound": 262.40074498268297 + }, + "point_estimate": 257.81954823695725, + "standard_error": 2.0075554085291265 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 256.39675019137087, + "upper_bound": 261.5581449697532 + }, + "point_estimate": 258.76085930918214, + "standard_error": 1.3276627897112634 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 253.97424725998468, + "upper_bound": 255.5790659360415 + }, + "point_estimate": 254.71649331435168, + "standard_error": 0.4098294208723699 + } + ], + "current": [ + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 226.63910690576273, + "upper_bound": 227.89825869160057 + }, + "point_estimate": 227.2317905222145, + "standard_error": 0.32176648896551313 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 228.2130426244259, + "upper_bound": 230.46995174091958 + }, + "point_estimate": 229.2775440514841, + "standard_error": 0.5770777242966283 + }, + { + "confidence_interval": { + "confidence_level": 0.95, + "lower_bound": 229.17336692146597, + "upper_bound": 238.32600143997817 + }, + "point_estimate": 233.16386537352926, + "standard_error": 2.3693975686543896 + } + ] + } + } +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-clippy.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-clippy.txt new file mode 100644 index 0000000..6dbc626 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-clippy.txt @@ -0,0 +1,12 @@ +memcap: <=7880 MiB (60% of 13134 MiB available) [systemd MemoryMax, swap off] + Checking serde_core v1.0.229 + Checking serde v1.0.229 + Checking fastrand v2.5.0 + Checking phf_generator v0.14.0 + Checking minijinja v2.24.0 + Checking serde_json v1.0.151 + Checking thiserror v2.0.21 + Checking phf_codegen v0.14.0 + Checking quick-xml v0.42.0 + Checking polyxml v0.34.6 (/home/bailey/github/polyxml-perf-cache/crates/polyxml-core) + Finished `dev` profile [unoptimized + debuginfo] target(s) in 5.05s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-focused-tests.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-focused-tests.txt new file mode 100644 index 0000000..4329b92 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/cache-policy-focused-tests.txt @@ -0,0 +1,37 @@ +memcap: <=7891 MiB (60% of 13151 MiB available) [systemd MemoryMax, swap off] + Compiling polyxml v0.34.6 (/home/bailey/github/polyxml-perf-cache/crates/polyxml-core) + Finished `test` profile [unoptimized + debuginfo] target(s) in 12.02s + Running unittests src/lib.rs (/home/bailey/github/PolyXML/target/debug/deps/polyxml-14071107435df7a7) + +running 16 tests +test integer::tests::comparison_uses_sign_and_magnitude ... ok +test ir::root_selection_tests::inherited_base_does_not_select_sibling_types ... ok +test ir::root_selection_tests::keeps_references_descendants_and_substitutions ... ok +test ir::root_selection_tests::rejects_missing_and_ambiguous_roots ... ok +test ir::chunker::tests::test_topological_scc_chunking_dag_invariants ... ok +test json::tests::test_json_deserialization_accepts_python_field_names ... ok +test json::tests::test_json_roundtrip_primitives ... ok +test tests::test_deserialization_does_not_confuse_xmlns_with_attributes ... ok +test tests::test_nested_elements_and_lists ... ok +test tests::test_namespaced_serialization ... ok +test ir::root_selection_tests::field_reference_keeps_substitution_group_members ... ok +test tests::test_roundtrip_serialization_deserialization ... ok +test tests::test_streaming_xml_item_stream ... ok +test pattern::tests::bounded_cache_evicts_and_retains_invalid_results ... ok +test pattern::tests::cache_matches_uncached_regex_under_churn_and_concurrency ... ok +test pattern::tests::cyclic_working_set_above_capacity_keeps_reusing_entries ... ok + +test result: ok. 16 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.15s + + Running tests/test_runtime_fast_paths.rs (/home/bailey/github/PolyXML/target/debug/deps/test_runtime_fast_paths-cb1357dd8af777c0) + +running 6 tests +test repeated_nested_records_validate_their_own_lexical_lists ... ok +test repeated_lexical_lists_keep_whitespace_validation ... ok +test lexical_list_formatting_preserves_escaping_empty_lists_and_long_numbers ... ok +test indexed_scalar_state_preserves_enum_pattern_and_split_text ... ok +test cached_patterns_keep_raw_restriction_and_trimmed_pattern_semantics ... ok +test unified_scalar_state_keeps_mixed_branch_order_nil_and_nested_frames ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/companion-sync.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/companion-sync.txt new file mode 100644 index 0000000..1c8aa81 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/companion-sync.txt @@ -0,0 +1,8 @@ +memcap: <=7779 MiB (60% of 12966 MiB available) [systemd MemoryMax, swap off] +Resolved 14 packages in 240ms + Building polyxml @ file:///home/bailey/github/PolyXML/crates/polyxml-python + Built polyxml @ file:///home/bailey/github/PolyXML/crates/polyxml-python +Prepared 1 package in 29.94s +Uninstalled 1 package in 0.39ms +Installed 1 package in 0.49ms + ~ polyxml==0.34.6 (from file:///home/bailey/github/PolyXML/crates/polyxml-python) diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus-reference.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus-reference.txt new file mode 100644 index 0000000..cf7a430 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus-reference.txt @@ -0,0 +1,57 @@ +memcap: <=7763 MiB (60% of 12939 MiB available) [systemd MemoryMax, swap off] + Building polyxml @ file:///home/bailey/github/PolyXML/crates/polyxml-python + Built polyxml @ file:///home/bailey/github/PolyXML/crates/polyxml-python +Uninstalled 1 package in 0.94ms +Installed 1 package in 0.60ms +╭───────────────────────────────────────────────────────────────────╮ +│ PolyXML W3C XML Schema Conformance Suite │ +│ Compiler Binary: /home/bailey/github/PolyXML/target/debug/polyxml │ +│ W3C Submodule: /home/bailey/github/polyxml-w3c-tests/w3c │ +│ Selected Suite: CType │ +╰───────────────────────────────────────────────────────────────────╯ +Executing 31 test group(s)... + + Testing CType/targetns00101m... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00 + + W3C XML Schema Conformance Summary +┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━┓ +┃ Category ┃ Count ┃ Rate ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━┩ +│ Total Test Groups │ 31 │ 100.0% │ +│ Schema Compilations Passed │ 31 │ 100.0% │ +│ Schema Compilations Failed │ 0 │ 0.0% │ +│ Valid Instances Evaluated │ 28 │ - │ +│ Roundtrip Validations Passed │ 23 │ 82.1% │ +└──────────────────────────────┴───────┴────────┘ + +Failures & Exceptions (5 groups): +┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓ +┃ ┃ ┃ Instances ┃ Error / First ┃ +┃ Suite/Group ┃ Schema Status ┃ (Pass/Total) ┃ Failure ┃ +┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━┩ +│ CType/basetd00101… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ Root.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'valu │ +│ CType/basetd00101… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ Root.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'valu │ +│ CType/derivationm… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ B.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'value' │ +│ CType/psubstituti… │ PASS │ 1/2 │ pSubstitutions001… │ +│ │ │ │ FAIL - Schema │ +│ │ │ │ error: Unexpected │ +│ │ │ │ root element │ +│ │ │ │ {pSubstitu │ +│ CType/psubstituti… │ PASS │ 1/2 │ pSubstitutions001… │ +│ │ │ │ FAIL - Schema │ +│ │ │ │ error: Unexpected │ +│ │ │ │ root element │ +│ │ │ │ {pSubstitu │ +└────────────────────┴───────────────┴────────────────────┴────────────────────┘ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus.txt new file mode 100644 index 0000000..90daa2a --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/corpus.txt @@ -0,0 +1,53 @@ +memcap: <=7607 MiB (60% of 12679 MiB available) [systemd MemoryMax, swap off] +╭───────────────────────────────────────────────────────────────────╮ +│ PolyXML W3C XML Schema Conformance Suite │ +│ Compiler Binary: /home/bailey/github/PolyXML/target/debug/polyxml │ +│ W3C Submodule: /home/bailey/github/polyxml-w3c-tests/w3c │ +│ Selected Suite: CType │ +╰───────────────────────────────────────────────────────────────────╯ +Executing 31 test group(s)... + + Testing CType/targetns00101m... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00 + + W3C XML Schema Conformance Summary +┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━┓ +┃ Category ┃ Count ┃ Rate ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━┩ +│ Total Test Groups │ 31 │ 100.0% │ +│ Schema Compilations Passed │ 31 │ 100.0% │ +│ Schema Compilations Failed │ 0 │ 0.0% │ +│ Valid Instances Evaluated │ 28 │ - │ +│ Roundtrip Validations Passed │ 23 │ 82.1% │ +└──────────────────────────────┴───────┴────────┘ + +Failures & Exceptions (5 groups): +┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓ +┃ ┃ ┃ Instances ┃ Error / First ┃ +┃ Suite/Group ┃ Schema Status ┃ (Pass/Total) ┃ Failure ┃ +┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━┩ +│ CType/basetd00101… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ Root.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'valu │ +│ CType/basetd00101… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ Root.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'valu │ +│ CType/derivationm… │ PASS │ 0/1 │ Positive: FAIL - │ +│ │ │ │ B.__init__() │ +│ │ │ │ missing 1 required │ +│ │ │ │ keyword-only │ +│ │ │ │ argument: 'value' │ +│ CType/psubstituti… │ PASS │ 1/2 │ pSubstitutions001… │ +│ │ │ │ FAIL - Schema │ +│ │ │ │ error: Unexpected │ +│ │ │ │ root element │ +│ │ │ │ {pSubstitu │ +│ CType/psubstituti… │ PASS │ 1/2 │ pSubstitutions001… │ +│ │ │ │ FAIL - Schema │ +│ │ │ │ error: Unexpected │ +│ │ │ │ root element │ +│ │ │ │ {pSubstitu │ +└────────────────────┴───────────────┴────────────────────┴────────────────────┘ diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/docs-build.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/docs-build.txt new file mode 100644 index 0000000..bb4192a --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/docs-build.txt @@ -0,0 +1,3 @@ +Build started +No issues found +Build finished in 0.84s diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/failed-corpus-preflight.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/failed-corpus-preflight.txt new file mode 100644 index 0000000..d29acdf --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/failed-corpus-preflight.txt @@ -0,0 +1,8 @@ +memcap: <=7869 MiB (60% of 13115 MiB available) [systemd MemoryMax, swap off] +╭──────────────────────────────────────────────────────────╮ +│ PolyXML W3C XML Schema Conformance Suite │ +│ Compiler Binary: polyxml │ +│ W3C Submodule: /home/bailey/github/polyxml-w3c-tests/w3c │ +│ Selected Suite: CType │ +╰──────────────────────────────────────────────────────────╯ +Error: PolyXML binary not found at polyxml! diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-control.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-control.txt new file mode 100644 index 0000000..3447ca0 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-control.txt @@ -0,0 +1,4 @@ +memcap: <=7889 MiB (60% of 13149 MiB available) [systemd MemoryMax, swap off] +memcap: <=7884 MiB (60% of 13140 MiB available) [systemd MemoryMax, swap off] +escaped XSD enumeration limitation: ScalarParseError { field: "value", expected: "enumeration", value: "R&D" } +nil mixed scalar serialization limitation: SerializationError("Invalid mixed content value for text") diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-selected.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-selected.txt new file mode 100644 index 0000000..0c39810 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits-selected.txt @@ -0,0 +1,4 @@ +memcap: <=7884 MiB (60% of 13141 MiB available) [systemd MemoryMax, swap off] +memcap: <=7858 MiB (60% of 13097 MiB available) [systemd MemoryMax, swap off] +escaped XSD enumeration limitation: ScalarParseError { field: "value", expected: "enumeration", value: "R&D" } +nil mixed scalar serialization limitation: SerializationError("Invalid mixed content value for text") diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits.rs b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits.rs new file mode 100644 index 0000000..b6fdeb6 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/known-limits.rs @@ -0,0 +1,25 @@ +use polyxml::schema::ModelSchema; +use polyxml::schema_parser::XsdParser; +use polyxml::{deserialize, serialize}; +use std::sync::Arc; + +fn main() { + let ir = XsdParser::new().parse_str(r#" + + + "#).unwrap(); + let schema = ModelSchema::from_ir(&ir, Some("Root")).unwrap(); + let error = deserialize(b"R&D", schema).unwrap_err(); + println!("escaped XSD enumeration limitation: {error:?}"); + + let ir = XsdParser::new().parse_str(r#" + + + + + "#).unwrap(); + let schema = ModelSchema::from_ir(&ir, Some("Root")).unwrap(); + let value = deserialize(b"Ready", Arc::clone(&schema)).unwrap(); + let error = serialize("Root", &value, &schema, None).unwrap_err(); + println!("nil mixed scalar serialization limitation: {error:?}"); +} diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/quality-gate.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/quality-gate.txt new file mode 100644 index 0000000..db78dad --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/quality-gate.txt @@ -0,0 +1,756 @@ +memcap: <=7878 MiB (60% of 13130 MiB available) [systemd MemoryMax, swap off] +==> [1/6] Running Rust format check (cargo fmt)... +==> [2/6] Running Rust Clippy (cargo clippy -D warnings)... + Checking polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling pyo3-ffi v0.29.2 + Compiling pyo3 v0.29.2 + Checking polyxml-cli v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-cli) + Checking polyxml-js v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-js) + Checking polyxml-wasm v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-wasm) + Checking polyxml-python v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-python) + Checking polyxml-c v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-c) + Finished `dev` profile [unoptimized + debuginfo] target(s) in 5.28s +==> [3/6] Running Rust workspace tests (cargo test)... + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling polyxml-cli v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-cli) + Compiling pyo3-ffi v0.29.2 + Compiling pyo3 v0.29.2 + Compiling polyxml-wasm v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-wasm) + Compiling polyxml-js v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-js) + Compiling polyxml-python v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-python) + Compiling polyxml-c v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-c) + Finished `test` profile [unoptimized + debuginfo] target(s) in 20.36s + Running unittests src/lib.rs (target/debug/deps/polyxml-675b717e531d04ed) + +running 16 tests +test integer::tests::comparison_uses_sign_and_magnitude ... ok +test ir::chunker::tests::test_topological_scc_chunking_dag_invariants ... ok +test ir::root_selection_tests::field_reference_keeps_substitution_group_members ... ok +test ir::root_selection_tests::inherited_base_does_not_select_sibling_types ... ok +test ir::root_selection_tests::keeps_references_descendants_and_substitutions ... ok +test ir::root_selection_tests::rejects_missing_and_ambiguous_roots ... ok +test json::tests::test_json_deserialization_accepts_python_field_names ... ok +test json::tests::test_json_roundtrip_primitives ... ok +test pattern::tests::bounded_cache_evicts_and_retains_invalid_results ... ok +test pattern::tests::cache_matches_uncached_regex_under_churn_and_concurrency ... ok +test pattern::tests::cyclic_working_set_above_capacity_keeps_reusing_entries ... ok +test tests::test_deserialization_does_not_confuse_xmlns_with_attributes ... ok +test tests::test_namespaced_serialization ... ok +test tests::test_nested_elements_and_lists ... ok +test tests::test_roundtrip_serialization_deserialization ... ok +test tests::test_streaming_xml_item_stream ... ok + +test result: ok. 16 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.18s + + Running tests/test_adversarial_identifiers.rs (target/debug/deps/test_adversarial_identifiers-34056256ccaa17cb) + +running 7 tests +test test_cpp_adversarial_compilation ... ok +test test_csharp_adversarial_compilation ... ok +test test_go_adversarial_compilation ... ok +test test_java_adversarial_compilation ... ok +test test_python_adversarial_compilation ... ok +test test_rust_adversarial_compilation ... ok +test test_typescript_adversarial_compilation ... ok + +test result: ok. 7 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 4.87s + + Running tests/test_any_attribute.rs (target/debug/deps/test_any_attribute-d5795d9c5e0fdefd) + +running 1 test +test test_any_attribute_schema_parser_and_runtime_roundtrip ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_any_element.rs (target/debug/deps/test_any_element-1fb225d6616938e8) + +running 2 tests +test test_any_element_go_codegen ... ok +test test_any_element_schema_parser_and_runtime_roundtrip ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_conformance.rs (target/debug/deps/test_conformance-0b37810d65fedfce) + +running 4 tests +test test_atom_feed_conformance ... ok +test test_soap_envelope_conformance ... ok +test test_streaming_catalog_conformance ... ok +test test_ubl_invoice_conformance ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/test_core.rs (target/debug/deps/test_core-f4cc1079f88df2bc) + +running 9 tests +test integer_mappings_keep_fixed_width_builtins ... ok +test test_all_scalar_types ... ok +test test_error_handling_invalid_scalars ... ok +test test_gregorian_partial_date_lexical_validation ... ok +test test_malformed_xml_syntax_error ... ok +test test_roundtrip_serialization_with_indentation ... ok +test test_xsd_gregorian_fields_round_trip_and_reject_invalid_dates ... ok +test test_xsi_nil_handling ... ok +test unbounded_integers_round_trip_and_compare_exact_bounds ... ok + +test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_cpp_codegen.rs (target/debug/deps/test_cpp_codegen-a4cd5571504c64d5) + +running 14 tests +test mixed_content_mutual_cycle_compiles ... ok +test mixed_content_self_cycle_compiles ... ok +test simple_aliases_follow_their_base_types ... ok +test test_cpp_choice_variant_compilation ... Choice pattern matching passed. +ok +test test_cpp_cmake_and_meson_generation ... ok +test test_cpp_cmake_modules_file_set ... ok +test test_cpp_from_xsd_schema ... ISO 20022 pacs.008 C++20 test passed. +ok +test test_cpp_glaze_backend_meta_generation ... ok +test test_cpp_inheritance_codegen ... Inheritance test passed. +ok +test test_cpp_mode_and_backend_from_str_loose ... ok +test test_cpp_modules_compilation ... ok +test test_cpp_recursive_cycle_unique_ptr ... Recursive tree unique_ptr passed. +ok +test test_cpp_sanitization ... ok +test test_cpp_struct_and_enum_codegen_compilation ... All C++20 tests passed successfully. +ok + +test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.00s + + Running tests/test_csharp_codegen.rs (target/debug/deps/test_csharp_codegen-cf32febf6e7f0777) + +running 20 tests +test choice_variants_avoid_record_member_names ... ok +test element_defaults_preserve_absence_and_empty_presence ... ok +test emits_unrestricted_simple_types_and_validates_empty_records ... ok +test fixed_values_are_enforced_on_read_and_write ... ok +test lexical_union_attributes_round_trip ... ok +test nillable_enum_collection_round_trips ... ok +test particle_wire_structure_round_trips ... ok +test test_csharp_any_attribute_codegen ... ok +test test_csharp_choice_polymorphic_hierarchy ... Determining projects to restore... + Restored /tmp/.tmpVL7MlE/PaymentsApp.csproj (in 168 ms). + PaymentsApp -> /tmp/.tmpVL7MlE/bin/Debug/net8.0/PaymentsApp.dll + +Build succeeded. + 0 Warning(s) + 0 Error(s) + +Time Elapsed 00:00:01.04 +Choice pattern matching and XML serialization passed! +ok +test test_csharp_date_or_datetime_lexical_union ... ok +test test_csharp_mutable_inheritance_roundtrip ... ok +test test_csharp_mutable_wrappers_and_choices_without_validation ... ok +test test_csharp_record_kind_from_str_loose ... ok +test test_csharp_records_and_enums_generation ... Determining projects to restore... + Restored /tmp/.tmpyFg5mE/CrmApp.csproj (in 168 ms). + CrmApp -> /tmp/.tmpyFg5mE/bin/Debug/net8.0/CrmApp.dll + +Build succeeded. + 0 Warning(s) + 0 Error(s) + +Time Elapsed 00:00:01.04 +Customer C# tests passed cleanly! +ok +test test_csharp_recursive_cycle ... Determining projects to restore... + Restored /tmp/.tmpWaFCyf/TreeApp.csproj (in 170 ms). + TreeApp -> /tmp/.tmpWaFCyf/bin/Debug/net8.0/TreeApp.dll + +Build succeeded. + 0 Warning(s) + 0 Error(s) + +Time Elapsed 00:00:01.03 +Recursive tree C# tests passed cleanly! +ok +test test_csharp_sanitization ... ok +test test_csharp_sequence_nested_inside_choice_codegen ... ok +test test_csharp_simple_content_class_validator_and_unsealed_records ... ok +test test_csharp_source_gen_context ... ok +test unbounded_integer_xml_preserves_digits ... ok + +test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 53.47s + + Running tests/test_go_codegen.rs (target/debug/deps/test_go_codegen-005c45ed4341be87) + +running 25 tests +test abstract_substitution_heads_are_rejected ... ok +test duplicate_choice_names_reject_invalid_branch_shapes ... ok +test imported_ordered_types_do_not_add_unused_bytes_import ... ok +test nested_lexical_unions_compile_and_round_trip_in_go ... ok +test ordered_particles_and_choice_branches_round_trip ... ok +test referenced_element_uses_declared_type_after_includes ... ok +test repeated_choice_branch_rejects_mixed_and_empty_selections ... ok +test repeated_sequence_groups_enforce_bounds_and_order ... ok +test root_alias_names_are_unique_after_go_normalization ... ok +test roots_and_union_attributes_round_trip ... ok +test separate_choices_enforce_each_group ... ok +test temporal_scalars_preserve_xsd_lexical_values ... ok +test test_go_abstract_xsi_type_dispatch ... ok +test test_go_any_attribute_codegen ... ok +test test_go_backend_from_str_loose ... ok +test test_go_choice_mutual_exclusivity ... go: creating new go.mod: module payments +go: to add module requirements and sums: + go mod tidy +=== RUN TestChoiceMutualExclusivity + payments_test.go:44: Correctly rejected concurrent choice branches: choice ContactChoice mutual exclusivity violation: multiple branches populated (2) +--- PASS: TestChoiceMutualExclusivity (0.00s) +PASS +ok payments 0.002s +ok +test test_go_date_or_datetime_lexical_union ... ok +test test_go_easyjson_backend ... ok +test test_go_enum_only_schema_omits_unused_xml_import ... ok +test test_go_namespaced_element_ref_matching ... ok +test test_go_recursive_cycle_pointers ... go: creating new go.mod: module tree +go: to add module requirements and sums: + go mod tidy +=== RUN TestRecursiveTree +--- PASS: TestRecursiveTree (0.00s) +PASS +ok tree 0.002s +ok +test test_go_sanitization ... ok +test test_go_sonic_backend ... ok +test test_go_struct_and_enum_generation ... go: creating new go.mod: module crm +go: to add module requirements and sums: + go mod tidy +=== RUN TestCustomerRoundtrip +--- PASS: TestCustomerRoundtrip (0.00s) +PASS +ok crm 0.002s +ok +test unbounded_integer_xml_preserves_digits ... ok + +test result: ok. 25 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.66s + + Running tests/test_java_codegen.rs (target/debug/deps/test_java_codegen-a6078e165fc64681) + +running 17 tests +test jackson3_preserves_core_annotations_and_maps_record_text ... ok +test test_direct_codec_rejects_wildcards_and_name_collisions ... ok +test test_java_bean_validation_annotations_are_opt_in ... ok +test test_java_direct_nil_lists_choices_and_namespaces ... ok +test test_java_identifier_sanitization ... ok +test test_java_jackson_backend_enum_annotations ... ok +test test_java_jackson_backend_from_str_loose ... ok +test test_java_jackson_backend_simple_type_annotations ... ok +test test_java_jackson_backend_struct_annotations ... ok +test test_java_jackson_backend_union_annotations ... ok +test test_java_module_container_class ... ok +test test_java_mutable_builders_and_direct_codecs_execute ... ok +test test_java_plain_record_extension_javac_execute ... ok +test test_java_plain_record_inlines_base_fields ... ok +test test_java_record_builder_and_nested_codec_execute ... ok +test test_java_records_and_enums_generation ... ok +test test_java_sealed_interface_choice ... ok + +test result: ok. 17 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 4.95s + + Running tests/test_json.rs (target/debug/deps/test_json-74440efee0e911e7) + +running 4 tests +test test_json_nested_objects_and_lists ... ok +test test_json_primitives_and_alias_modes ... ok +test test_json_scalar_coercion ... ok +test test_polyvalue_direct_json_methods ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_lexical_lists.rs (target/debug/deps/test_lexical_lists-0f6750d9c4bf9a3c) + +running 2 tests +test named_list_items_enforce_facets_and_enumerations ... ok +test typed_lexical_lists_round_trip_across_codecs ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 4.92s + + Running tests/test_lexical_union_codegen.rs (target/debug/deps/test_lexical_union_codegen-3c208893561d2732) + +running 2 tests +test lexical_union_xml_selects_first_valid_member_and_round_trips ... ok +test lexical_unions_are_typed_in_all_targets ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_mixed_content.rs (target/debug/deps/test_mixed_content-1a697ad935ae2797) + +running 5 tests +test generated_models_keep_typed_content_items_in_all_targets ... ok +test mixed_content_preserves_nested_child_order ... ok +test mixed_content_preserves_text_and_child_order ... ok +test mixed_items_field_avoids_existing_attribute_name ... ok +test parser_builds_ordered_mixed_content_union ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_pattern_codegen.rs (target/debug/deps/test_pattern_codegen-5eee5f9fe2ed3d1a) + +running 9 tests +test generated_cpp_pattern_validation ... ok +test generated_csharp_pattern_validation ... ok +test generated_go_pattern_validation_and_xml_roundtrip ... ok +test generated_java_pattern_validation_and_direct_codecs ... ok +test generated_python_pattern_validation ... ok +test generated_rust_pattern_validation_and_xml_roundtrip ... ok +test generated_typescript_pattern_validation_all_backends ... ok +test gregorian_primitives_emit_validated_types_across_targets ... ok +test pattern_restrictions_preserve_or_groups_and_inherited_and_steps ... ok + +test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 5.73s + + Running tests/test_python_codegen.rs (target/debug/deps/test_python_codegen-cc734e908fb39fb6) + +running 16 tests +test multiline_xsd_documentation_stays_inside_python_comments ... ok +test quoted_docstrings_preserve_text_and_remain_valid_python ... ok +test test_identifier_sanitization ... ok +test test_python_abstract_meta_emission ... ok +test test_python_any_attribute_codegen ... ok +test test_python_any_element_codegen ... ok +test test_python_aot_codegen ... ok +test test_python_choice_union_codegen ... ok +test test_python_codecs_generation ... ok +test test_python_dataclass_codegen ... ok +test test_python_derived_meta_inheritance ... ok +test test_python_generated_tag_and_custom_header ... ok +test test_python_pydantic_codegen_with_facets ... ok +test test_python_recursive_type_codegen ... ok +test test_python_sequence_nested_inside_choice_codegen ... ok +test test_python_simplecontent_default_factory ... ok + +test result: ok. 16 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.05s + + Running tests/test_qualified_attributes.rs (target/debug/deps/test_qualified_attributes-f8397a31cf1ecf15) + +running 5 tests +test derived_validators_preserve_base_constraints ... ok +test global_attribute_references_round_trip_by_namespace ... ok +test imported_inline_global_attribute_enum_round_trips ... ok +test inherited_attribute_and_distinct_element_keep_separate_property_names ... ok +test lexical_dependencies_compile_and_round_trip_without_implicit_imports ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 25.87s + + Running tests/test_runtime_fast_paths.rs (target/debug/deps/test_runtime_fast_paths-7bf9091b7252b7db) + +running 6 tests +test cached_patterns_keep_raw_restriction_and_trimmed_pattern_semantics ... ok +test indexed_scalar_state_preserves_enum_pattern_and_split_text ... ok +test lexical_list_formatting_preserves_escaping_empty_lists_and_long_numbers ... ok +test repeated_lexical_lists_keep_whitespace_validation ... ok +test repeated_nested_records_validate_their_own_lexical_lists ... ok +test unified_scalar_state_keeps_mixed_branch_order_nil_and_nested_frames ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_rust_codecs.rs (target/debug/deps/test_rust_codecs-9692e165bd5e14bf) + +running 4 tests +test test_empty_element_codec ... ok +test test_facet_validation_min_max_length ... ok +test test_order_choice_roundtrip ... ok +test test_recursive_boxing_roundtrip ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_rust_codegen.rs (target/debug/deps/test_rust_codegen-8bce8b4b67c7eca3) + +running 26 tests +test binary_lexical_values_compile_and_round_trip_in_owned_and_borrowed_modes ... ok +test duplicate_wire_names_keep_distinct_json_values ... ok +test empty_modules_compile_without_unused_reexports ... ok +test multiline_docs_and_raw_field_names_are_valid_source ... ok +test named_choice_wrappers_round_trip_without_unreachable_dispatch ... ok +test test_rust_attribute_codec_loop_syntax ... ok +test test_rust_choice_union_codegen ... ok +test test_rust_codecs_codegen ... ok +test test_rust_digit_prefixed_module_sanitization ... ok +test test_rust_enum_and_methods ... ok +test test_rust_extension_base_cycle_cut ... ok +test test_rust_extension_codecs_decode_and_encode_base_fields ... ok +test test_rust_extension_inlines_base_fields ... ok +test test_rust_identifier_sanitization ... ok +test test_rust_owned_codegen ... ok +test test_rust_phf_dispatch_emission ... ok +test test_rust_phf_dispatch_union_groups_branch_tags ... ok +test test_rust_phf_dispatch_uniquifies_like_field_metas ... ok +test test_rust_read_element_text_accumulates_refs_and_cdata ... ok +test test_rust_recursive_cycle_boxing ... ok +test test_rust_rkyv_derives ... ok +test test_rust_simple_content_extension_shadow_rule ... ok +test test_rust_simple_content_text_codec ... ok +test test_rust_simple_type_cycle_resilience ... ok +test test_rust_topological_scc_chunking ... ok +test test_rust_zero_copy_codegen ... ok + +test result: ok. 26 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 15.80s + + Running tests/test_schema_audit.rs (target/debug/deps/test_schema_audit-24992dfb5b4a626c) + +running 13 tests +test all_languages_disambiguate_flat_collision ... ok +test chameleon_include_adopts_including_namespace_per_includer ... ok +test derived_simple_type_inherits_base_patterns ... ok +test diamond_includes_do_not_duplicate_upa_source_documents ... ok +test distinct_values_with_colliding_variant_names_stay_unique ... ok +test duplicate_enumeration_values_are_deduped ... ok +test generated_rust_has_no_deny_unknown_fields ... ok +test named_group_reference_fields_are_parsed ... ok +test nested_inline_complex_type_is_extracted_not_leaked ... ok +test quick_xml_serde_skips_unknown_elements ... ok +test restricted_simple_types_emit_named_aliases ... ok +test rust_flat_output_has_no_colliding_type_names ... ok +test simple_content_extension_emits_value_field ... ok + +test result: ok. 13 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/test_schema_ir.rs (target/debug/deps/test_schema_ir-f793c1b9895343c7) + +running 20 tests +test consumed_child_subtrees_do_not_swallow_following_types ... ok +test consumed_particles_do_not_swallow_following_declarations ... ok +test derived_complex_type_keeps_base_and_bounded_choice ... ok +test global_attribute_reference_uses_declared_type ... ok +test imported_inline_global_attribute_types_are_resolved ... ok +test inline_list_item_types_preserve_enum_and_union_declarations ... ok +test missing_included_schema_is_an_error ... ok +test schema_errors_preserve_forward_imports_and_annotation_payloads ... ok +test schema_for_schemas_declared_types_are_not_unknown_builtins ... ok +test test_language_context_adapter ... ok +test test_list_fields_do_not_trigger_spurious_cycles ... ok +test test_minijinja_template_engine_and_filters ... ok +test test_parse_choice_as_union ... ok +test test_parse_complex_type_and_facets ... ok +test test_parse_lexical_union_member_types_and_inline_members ... ok +test test_sequence_nested_inside_choice_preserved_in_ir ... ok +test test_substitution_groups ... ok +test test_tarjan_mutual_recursive_cycle_detection_and_boxing ... ok +test test_tarjan_self_recursive_cycle_detection_and_boxing ... ok +test xml_prefix_is_available_without_explicit_declaration ... ok + +test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/test_security.rs (target/debug/deps/test_security-c3afa670f1d6c619) + +running 6 tests +test test_cdata_section_handling ... ok +test test_malformed_unclosed_cdata_rejection ... ok +test test_max_depth_recursion_limit ... ok +test test_numeric_character_references ... ok +test test_xml_entity_roundtrip_escaping ... ok +test unsupported_general_entities_are_rejected ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_temporal_union.rs (target/debug/deps/test_temporal_union-e25d1f9b83e2fdc4) + +running 2 tests +test csharp_temporal_union_preserves_branches_and_lexicals ... ok +test go_temporal_union_preserves_branches_and_lexicals ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.22s + + Running tests/test_transcoder.rs (target/debug/deps/test_transcoder-6854114408316a2e) + +running 6 tests +test test_schema_directed_transcoding ... ok +test test_schema_from_ir_transcoding ... ok +test test_schemaless_preserves_refs_cdata_and_attr_entities ... ok +test test_schemaless_pretty_transcoding ... ok +test test_schemaless_xml_to_json_and_back ... ok +test test_transcoder_errors ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_ts_codegen.rs (target/debug/deps/test_ts_codegen-4e67290c9758f4d9) + +running 9 tests +test mixed_content_inheritance_compiles_with_widened_items ... ok +test test_ts_backend_from_str_loose ... ok +test test_ts_discriminated_union_choice ... ok +test test_ts_identifier_sanitization ... ok +test test_ts_interface_and_enum_codegen ... ok +test test_ts_recursive_cycle_zod_lazy ... ok +test test_ts_typebox_schema_generation ... ok +test test_ts_valibot_schema_generation ... ok +test test_ts_zod_schema_generation ... ok + +test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.32s + + Running tests/test_ubl_csharp.rs (target/debug/deps/test_ubl_csharp-b04bc8d2d5f891c2) + +running 2 tests +test multi_namespace_roots_and_inherited_simple_content_compile_and_round_trip ... ok +test unprefixed_xsd_builtin_simple_content_base_uses_default_namespace ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.03s + + Running tests/test_unbounded_choice.rs (target/debug/deps/test_unbounded_choice-7672e62aa5ecca1a) + +running 1 test +test test_unbounded_choice_ir_and_all_targets ... go: creating new go.mod: module testmod +go: to add module requirements and sums: + go mod tidy +=== RUN TestUnboundedChoiceOrder +--- PASS: TestUnboundedChoiceOrder (0.00s) +PASS +ok testmod 0.002s +ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.15s + + Running tests/test_upa.rs (target/debug/deps/test_upa-a20019d257c7eac5) + +running 6 tests +test all_groups_and_wildcard_namespaces_are_checked ... ok +test imported_groups_and_chameleon_wildcards_keep_source_namespaces ... ok +test local_form_and_in_scope_qnames_distinguish_namespaces ... ok +test model_groups_derivation_and_substitution_members_are_checked ... ok +test occurrence_ranges_keep_particle_identity_and_count_boundaries ... ok +test optional_siblings_and_choice_lookahead_violate_upa ... ok + +test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/test_value_constraints.rs (target/debug/deps/test_value_constraints-73eb81a96de588c1) + +running 2 tests +test fixed_constraints_cover_input_and_output_in_value_space ... ok +test repeated_particle_cardinality_belongs_to_the_group ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_xsi_type.rs (target/debug/deps/test_xsi_type-2c07a0776bd0ec60) + +running 11 tests +test abstract_type_requires_concrete_selector ... ok +test abstract_type_without_derivations_errors ... ok +test from_ir_flattens_base_fields_and_registers_variants ... ok +test iterparse_dispatches_each_streamed_item ... ok +test nested_xsi_type_dispatch_and_round_trip ... ok +test nil_abstract_complex_type_skips_concrete_dispatch ... ok +test plain_type_attribute_is_not_mistaken_for_dispatch ... ok +test root_xsi_type_dispatch_including_empty_element ... ok +test unknown_xsi_type_on_abstract_type_errors ... ok +test variant_serialization_requires_namespaces ... ok +test xsi_type_resolves_namespace_inherited_from_parent ... ok + +test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running unittests src/lib.rs (target/debug/deps/polyxml-4ccc220bbd6a27a0) + +running 2 tests +test tests::test_c_abi_namespaced_roundtrip ... ok +test tests::test_c_abi_nested_list_batch_roundtrip ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/polyxml_cli-dabf613ae4318f1b) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/debug/deps/polyxml-cec02944de7101b9) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/test_cli.rs (target/debug/deps/test_cli-714ccf0c30d96734) + +running 47 tests +test bash_completion_filters_values_in_the_shell ... ok +test completion_candidates_follow_target_validation ... ok +test fish_completion_filters_values_when_available ... ok +test imported_substitution_helpers_do_not_require_spurious_module_owners ... ok +test invalid_schema_grammar_and_types_fail_before_generation ... ok +test jackson3_cli_and_manifest_emit_equivalent_models ... ok +test manifest_generation_does_not_ignore_cli_overrides ... ok +test python_features_respect_manifest_false_values_and_backend ... ok +test retained_imported_ordered_helpers_belong_to_the_unique_namespace_module ... ok +test test_cli_build_polyxml_manifest_with_new_features ... Loading manifest: /tmp/.tmpNGaN5p/polyxml.toml +Compiling schema: /tmp/.tmpNGaN5p/model.xsd + Namespace: urn:app + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Emitting target [csharp] into /tmp/.tmpNGaN5p/cs +Emitting target [ts] into /tmp/.tmpNGaN5p/ts +Emitting target [go] into /tmp/.tmpNGaN5p/go +Emitting target [rust] into /tmp/.tmpNGaN5p/rs +Build finished successfully. +ok +test test_cli_cpp_generation ... E2E C++20 driver passed! +ok +test test_cli_cpp_modules_and_glaze ... ok +test test_cli_csharp_generation ... Determining projects to restore... + Restored /tmp/.tmpgtPcI5/cli_csharp_app/CrmCliApp.csproj (in 169 ms). + CrmCliApp -> /tmp/.tmpgtPcI5/cli_csharp_app/bin/Debug/net8.0/CrmCliApp.dll + +Build succeeded. + 0 Warning(s) + 0 Error(s) + +Time Elapsed 00:00:01.03 +E2E C# CLI test passed successfully! +ok +test test_cli_csharp_source_gen_and_record_struct ... Parsing schema: /tmp/.tmpnQfb9M/customer.xsd + Namespace: urn:crm + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +ok +test test_cli_generate_custom_header_and_generated_tags ... ok +test test_cli_generate_dry_run ... ok +test test_cli_generate_help ... ok +test test_cli_generate_multi_lang ... ok +test test_cli_generate_python_backends ... ok +test test_cli_generate_rust_zero_copy_and_owned ... ok +test test_cli_go_easyjson_and_sonic_backend ... Parsing schema: /tmp/.tmpXNuVxP/service.xsd + Namespace: urn:service + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +Parsing schema: /tmp/.tmpXNuVxP/service.xsd + Namespace: urn:service + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +ok +test test_cli_go_generation ... go: creating new go.mod: module crm +go: to add module requirements and sums: + go mod tidy +=== RUN TestAccountE2E +--- PASS: TestAccountE2E (0.00s) +PASS +ok crm 0.002s +ok +test test_cli_help ... ok +test test_cli_java_generation ... ok +test test_cli_manifest_custom_header_workspace_and_target_override ... Loading manifest: /tmp/.tmp1YmB2V/polyxml.toml +Compiling schema: /tmp/.tmp1YmB2V/schema.xsd + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Emitting target [rust] into /tmp/.tmp1YmB2V/rs +Emitting target [go] into /tmp/.tmp1YmB2V/go +Emitting target [csharp] into /tmp/.tmp1YmB2V/cs +Build finished successfully. +ok +test test_cli_multiple_root_element_selection ... ok +test test_cli_python_aot_generation ... ok +test test_cli_python_aot_rejects_dataclass_style_and_slots ... ok +test test_cli_root_element_selection ... ok +test test_cli_rust_phf_feature ... Parsing schema: /tmp/.tmpmnW825/event.xsd + Namespace: urn:events + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +ok +test test_cli_rust_rkyv_feature ... Parsing schema: /tmp/.tmpkubLF6/event.xsd + Namespace: urn:events + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +ok +test test_cli_rust_split_units_and_chunking ... ok +test test_cli_shared_modules_deduplication ... ok +test test_cli_transcode_bidirectional ... ok +test test_cli_typescript_generation ... ok +test test_cli_typescript_valibot_and_typebox_backend ... Parsing schema: /tmp/.tmpvtAuGk/item.xsd + Namespace: urn:store + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +Parsing schema: /tmp/.tmpvtAuGk/item.xsd + Namespace: urn:store + Types: 1 total (1 structs, 0 enums, 0 unions, 0 simple restrictions) + Root elements: 0 +Code generation complete. +ok +test test_cli_validate_valid_and_invalid ... ok +test test_java_csharp_model_style_options_and_manifest ... ok +test test_polyxml_toml_manifest_build ... ok +test test_root_selection_keeps_imported_module_types ... ok +test unified_help_shows_generation_options ... ok +test unified_manifest_forms_generate_identical_output_and_validate_early ... ok +test unified_options_fail_before_schema_io_including_dry_run ... ok +test unified_supported_backends_and_styles_validate ... ok +test unsupported_xsd_alternatives_fail_explicitly ... ok +test validate_and_generate_reject_upa_violations ... ok +test zsh_completion_filters_values_when_available ... ok + +test result: ok. 47 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 18.44s + + Running unittests src/lib.rs (target/debug/deps/polyxml_js-878a75d7b7901cc9) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/_polyxml-a668b0910babaf29) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/polyxml_wasm-d510c7f48918b595) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Doc-tests polyxml + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Doc-tests polyxml_cli + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Doc-tests polyxml_wasm + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + +==> [4/6] Compiling Python PyO3 extension (maturin develop)... +🍹 Building a mixed python/rust project +🐍 Found CPython 3.14 at /home/bailey/github/PolyXML/.venv/bin/python +🔗 Found pyo3 bindings with abi3-py3.12 support +📡 Using build options features from pyproject.toml +Using Python 3.14.4 environment at: /home/bailey/github/PolyXML/.venv +Checked 6 packages in 0.52ms + Compiling pyo3-ffi v0.29.2 + Compiling pyo3 v0.29.2 + Compiling polyxml v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-core) + Compiling polyxml-python v0.34.6 (/home/bailey/github/PolyXML/crates/polyxml-python) + Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.08s +📦 Built wheel for abi3 Python ≥ 3.12 to /tmp/.tmpt1UoBV/polyxml-0.34.6-cp312-abi3-linux_x86_64.whl +✏️ Setting installed package as editable +🛠 Installed polyxml-0.34.6 +==> [5/6] Running Python Ruff checks... +All checks passed! +10 files already formatted +==> [6/6] Running Python tests with 100% statement & branch coverage... +........................................................................ [ 64%] +........................................ [100%] +================================ tests coverage ================================ +_______________ coverage: platform linux, python 3.14.4-final-0 ________________ + +Name Stmts Miss Branch BrPart Cover Missing +--------------------------------------------------- +TOTAL 181 0 58 0 100% + +3 files skipped due to complete coverage. +Required test coverage of 100% reached. Total coverage: 100.00% +112 passed in 0.51s +✨ All PolyXML dual-language quality gates passed! diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/tooling-checks.txt b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/tooling-checks.txt new file mode 100644 index 0000000..8d76f96 --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/tooling-checks.txt @@ -0,0 +1,3 @@ +All checks passed! +3 files already formatted +Skill is valid! diff --git a/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/verification.json b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/verification.json new file mode 100644 index 0000000..42943ff --- /dev/null +++ b/docs/benchmarks/data/2026-10-03/runtime-optimization/verification/verification.json @@ -0,0 +1,26 @@ +{ + "archive_hashes": "pass", + "criterion_summaries_reconstructed_from_archives": "pass", + "shared_dependency_versions": "pass", + "generated_model_bytes_identical": "pass", + "measured_core_revision": "7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d", + "control_revision": "bbbd087a9a8e9838a32912973cd4029c30f29c08", + "historical_revision": "cef575c11cc4f05e877ced157036f7ff53b8687b", + "rust_tests_passed": 321, + "python_tests_passed": 112, + "python_statement_and_branch_coverage_percent": 100, + "corpus_schema_expectations": [ + 31, + 31 + ], + "corpus_instance_roundtrips": [ + 23, + 28 + ], + "corpus_summary_and_group_table_matches_reference": true, + "corpus_reference_source_sha": "not recorded in original log", + "oom": false, + "main_modified": false, + "strict_docs_build": "pass", + "benchmark_tooling_checks": "pass" +} diff --git a/docs/benchmarks/index.md b/docs/benchmarks/index.md index ec97778..e8fe58c 100644 --- a/docs/benchmarks/index.md +++ b/docs/benchmarks/index.md @@ -38,6 +38,9 @@ lists every entry point. ## Published studies +- [October 2026 dynamic Rust XML optimization](rust-runtime-optimization-2026-10.md): + branch experiments, allocation diagnostics and same-host confirmation. + - [October 2026 Rust XML/Serde regression check](rust-xml-serde-regression-2026-10.md): same-host generated-model and dynamic-core comparisons with retained samples. diff --git a/docs/benchmarks/rust-runtime-optimization-2026-10.md b/docs/benchmarks/rust-runtime-optimization-2026-10.md new file mode 100644 index 0000000..2a8ce91 --- /dev/null +++ b/docs/benchmarks/rust-runtime-optimization-2026-10.md @@ -0,0 +1,263 @@ +--- +title: Rust XML runtime optimization — October 2026 +description: Dynamic XML optimization experiments with instruction profiles, allocation counts and retained same-host comparisons. +--- + +# Rust XML runtime optimization — October 2026 + +The retained branch improves plain XML writes by **18–20%** and rich-enum reads +by about **45%** versus 0.34.6 on these fixtures. Warm scalar-pattern workloads +improve much more by removing repeated regex compilation. Plain catalog reads +still cost approximately **5% more than 0.27.0**. The tables below link the samples +and process estimates supporting each result. + +This follows the [XML/Serde regression audit](rust-xml-serde-regression-2026-10.md). +The optimization changes the dynamic, schema-driven Rust XML engine. Generated +Rust models use their own quick-xml methods and Serde JSON implementations. +Their emitted model sources remain byte-identical in this comparison. + +## Retained changes + +- Append XML directly to a byte vector, replacing a cursor over that vector. +- Format lexical lists into one string rather than allocating individual token + strings and collecting a vector before joining. Keep primitive formatting inline. +- Select fixed-value and lexical-list obligations before prevalidation; skip + recursive list scans for ordinary repeated records. Nested writers retain + their own validation. +- Store active field/branch indices in the parser and borrow scalar metadata + from the frame's schema. Avoid cloning enum members and pattern strings for + every value. Consolidate ordinary/mixed scalar state and move nested mixed + branch names into the resulting object. +- Reuse exactly anchored scalar regexes through a concurrent cache. It admits + 16 entries with keys up to 4,096 bytes. Larger keys compile uncached; invalid + expressions retain the previous validation failure. Matching and compilation + run outside the lock. At capacity, an eviction nonce and the existing randomized + hasher select a victim, avoiding the FIFO prototype's cyclic misses. + +The cache keys actual pattern strings, and parser indices resolve actual field +metadata. Public schema edits before sharing do not leave stale prepared flags. +Fixed values, lexical-list whitespace rejection, content-model validation and +scalar restrictions remain enabled. Cache limits bound entries/key retention, +**not compiled-regex bytes or peak memory**. Concurrent misses can compile the +same expression more than once before one result is retained. + +## Method + +The measured implementation is +[`7f845ae`](https://github.com/polyxml/PolyXML/commit/7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d). +The control is [`bbbd087` (0.34.6)](https://github.com/polyxml/PolyXML/commit/bbbd087a9a8e9838a32912973cd4029c30f29c08). +The historical comparison uses [`cef575c` (0.27.0)](https://github.com/polyxml/PolyXML/commit/cef575c11cc4f05e877ced157036f7ff53b8687b). +Each comparison records exact revisions and clean core-source status in its +metadata. Subsequent documentation commits do not change the measured engine. + +The host is an Intel Core i5-11600K under WSL2, rustc 1.99.0 / LLVM 23.1.1. +Confirmation builds and measurements run serially, with one Cargo worker, +systemd memory caps at 60% of available RAM, and swap disabled inside each scope. +The IDE is present; affinity and CPU frequency are not pinned. No OOM occurred. + +All Criterion confirmation suites use three processes per revision, 100 samples, +three-second warmup and five-second measurement targets. Order alternates +baseline/candidate, candidate/baseline, baseline/candidate. Tables use the median +of process mean estimates. Each process's confidence interval and paired delta +remain in the summary; samples within a process are not independent process +repetitions. Small deltas deserve more caution than the large gains. + +The core harness checks round-trip equality and catalog counts before timing. +Payloads are 94 bytes for the sensor and 63,911 / 668,911 bytes for catalogs; +written catalogs are 63,411 / 663,911 bytes because numeric spelling normalizes. +The constraint harness checks every value and round trips: 1,000 enum values, +patterned strings, restricted strings, lexical integer lists, or strings with a +content regex. Scalar-pattern cases measure warm reuse, excluding first +compilation. Working-set pressure receives a separate suite; concurrent +throughput and cold-start latency are unmeasured. + +The [investigation toolkit](https://github.com/polyxml/PolyXML/tree/7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d/benchmarks/rust-runtime-investigation) +and [comparison runner](https://github.com/polyxml/PolyXML/tree/7f845ae043b68cdb3166d04ce74eaa99bc9c2b0d/benchmarks/rust-xml-regression) +contain reproduction commands. Criterion filters are regexes: `^serialization/` +selects writes; `serialization` also matches deserialization. + +## Plain-record confirmation + +[Process estimates](data/2026-10-03/runtime-optimization/selected-core/summary.json) and +[all Criterion samples](data/2026-10-03/runtime-optimization/selected-core/samples.tar.gz) support this table. +The first confirmation attempt is retained in the prototype archive and excluded: +a companion `uv run ... --help` unexpectedly rebuilt its editable binding during +the final round. Both the clean repeat and the later retained-policy run are saved. + +| Operation | Fixture | 0.34.6 µs | Candidate µs | Change | +| --- | --- | ---: | ---: | ---: | +| read | catalog 1000 | 797.834 | 788.425 | -1.18% | +| read | catalog 10000 | 8,011.487 | 7,932.545 | -0.99% | +| read | sensor | 1.046 | 1.012 | -3.16% | +| write | catalog 1000 | 223.146 | 179.231 | -19.68% | +| write | catalog 10000 | 2,253.219 | 1,800.463 | -20.09% | +| write | sensor | 0.279 | 0.228 | -18.42% | + +All write fixtures improve across all three paired processes. Catalog read +changes are small; the sensor gain should not be generalized to larger documents. + +## Historical release comparison + +[Process estimates](data/2026-10-03/runtime-optimization/selected-old-core/summary.json) and +[raw samples](data/2026-10-03/runtime-optimization/selected-old-core/samples.tar.gz) support this fresh same-host +comparison, rather than a ratio of separate studies. + +| Operation | Fixture | 0.27.0 µs | Candidate µs | Change | +| --- | --- | ---: | ---: | ---: | +| read | catalog 1000 | 755.809 | 796.211 | +5.35% | +| read | catalog 10000 | 7,585.809 | 7,963.984 | +4.99% | +| read | sensor | 0.975 | 1.009 | +3.50% | +| write | catalog 1000 | 200.999 | 180.104 | -10.40% | +| write | catalog 10000 | 2,005.150 | 1,806.558 | -9.90% | +| write | sensor | 0.258 | 0.229 | -11.07% | + +Writes recover the historical regression and improve further. Catalog reads +still cost approximately 5% more than 0.27.0; full read recovery remains unresolved. + +## Constrained scalar workloads + +[Process estimates](data/2026-10-03/runtime-optimization/selected-constraints/summary.json) and +[raw samples](data/2026-10-03/runtime-optimization/selected-constraints/samples.tar.gz) support this table. +Times are microseconds per 1,000-value document. + +| Operation | Constraint | 0.34.6 µs | Candidate µs | Change | +| --- | --- | ---: | ---: | ---: | +| read | content | 192.784 | 193.025 | +0.13% | +| read | enum | 351.979 | 194.919 | -44.62% | +| read | list | 282.413 | 268.777 | -4.83% | +| read | pattern | 10,165.972 | 230.009 | -97.74% | +| read | restricted | 10,279.245 | 243.834 | -97.63% | +| write | content | 48.653 | 37.219 | -23.50% | +| write | enum | 69.108 | 53.182 | -23.04% | +| write | list | 232.458 | 191.602 | -17.58% | +| write | pattern | 9,603.202 | 92.221 | -99.04% | +| write | restricted | 9,557.319 | 103.450 | -98.92% | + +Enum reads improve consistently in all three processes. Lexical-list reads have +a smaller gain; content-model reads remain approximately unchanged. Pattern +speedups are specific to warm reuse: the control compiles a regex for every +scalar, while the candidate reuses it. Both validate every value. + +## Pattern working-set pressure + +[Process estimates](data/2026-10-03/runtime-optimization/selected-cache-boundaries/summary.json) and +[raw samples](data/2026-10-03/runtime-optimization/selected-cache-boundaries/samples.tar.gz) support this table. +There are eight values per pattern. Reads cycle through keys; writes visit each +field's eight occurrences consecutively. Compare revisions within each row, +because document sizes vary with the number of patterns. + +| Operation | Active patterns | 0.34.6 µs | Candidate µs | Change | +| --- | --- | ---: | ---: | ---: | +| read | 1 | 78.357 | 2.320 | -97.04% | +| read | 16 | 1,276.524 | 34.537 | -97.29% | +| read | 17 | 1,358.826 | 206.634 | -84.79% | +| read | 64 | 5,238.168 | 5,254.703 | +0.32% | +| write | 1 | 72.397 | 0.796 | -98.90% | +| write | 16 | 1,178.806 | 12.870 | -98.91% | +| write | 17 | 1,249.130 | 34.669 | -97.22% | +| write | 64 | 4,926.045 | 689.333 | -86.01% | + +At 17 patterns, the FIFO prototype was about 4% slower than the control on reads +in both short screening passes. Salted victim selection retains reuse under +that cycle without raising capacity. Against FIFO, the policy screening showed +about 7× faster reads and 5× faster writes for 17 patterns. The retained policy's +longer comparison above confirms gains against the unoptimized control. +At 64 patterns, reads remain approximately unchanged; field-local reuse still +helps writes. This is a bounded reuse cache, rather than a prepared-schema index. + +## Generated Rust XML and JSON/Serde control + +[Per-process values](data/2026-10-03/runtime-optimization/selected-generated/summary.json), +[metadata](data/2026-10-03/runtime-optimization/selected-generated/metadata.json), and the retained CSVs/model +sources support this four-round control. Each operation has 100 warmup calls, +then seven samples of at least 250ms; the table uses the median of each process's +sample medians, followed by the median across processes. All fields and round +trips are checked before timing, and XML writes specify the declared Batch root. + +| Operation | Mode / sensors | 0.34.6 µs | Candidate µs | Change | +| --- | --- | ---: | ---: | ---: | +| json read | borrowed / 1 | 0.0821 | 0.0803 | -2.18% | +| json read | borrowed / 1000 | 60.3231 | 58.9033 | -2.35% | +| json write | borrowed / 1 | 0.0383 | 0.0403 | +5.44% | +| json write | borrowed / 1000 | 25.6639 | 25.9780 | +1.22% | +| xml read | borrowed / 1 | 0.3000 | 0.2873 | -4.26% | +| xml read | borrowed / 1000 | 194.6537 | 185.7288 | -4.58% | +| xml write | borrowed / 1 | 0.1708 | 0.1712 | +0.24% | +| xml write | borrowed / 1000 | 54.2813 | 51.6765 | -4.80% | +| json read | owned / 1 | 0.0808 | 0.0809 | +0.13% | +| json read | owned / 1000 | 59.2453 | 59.6227 | +0.64% | +| json write | owned / 1 | 0.0366 | 0.0367 | +0.40% | +| json write | owned / 1000 | 24.2438 | 24.1003 | -0.59% | +| xml read | owned / 1 | 0.3133 | 0.3145 | +0.38% | +| xml read | owned / 1000 | 234.4708 | 233.4626 | -0.43% | +| xml write | owned / 1 | 0.1750 | 0.1787 | +2.15% | +| xml write | owned / 1000 | 80.0840 | 80.6449 | +0.70% | + +There is no material batch slowdown in this control. Some tiny writer cases cost +approximately 2–4 ns more, and borrowed XML batches improve in these builds. +Model sources are identical; these observations do not establish a general +Serde speedup. An apparent borrowed JSON batch-write slowdown in the initial +two-round screen disappeared in the four-round repeat; both attempts are retained. + +## Profiling and allocations + +The [0.27.0 allocation log](data/2026-10-03/runtime-optimization/diagnostics/old/old-allocations.txt), +[0.34.6 log](data/2026-10-03/runtime-optimization/diagnostics/control/control-allocations.txt), and +[retained-policy log](data/2026-10-03/runtime-optimization/diagnostics/selected/selected-allocations.txt) +show identical allocation counts on the plain fixtures. At 1,000 catalog records, +reads allocate 5,010 times and reallocate 1,014 times; writes allocate 1,001 times +and reallocate 2,007 times. Requested read bytes grew by 768 per document between +0.27.0 and 0.34.6, consistent with 48 bytes of growth across 16 reserved stack +frames. This is cumulative requested memory, **not peak RSS or retained memory**. + +The logs record `FieldSchema` growing from 96 to 160 bytes, `ScalarType` from 1 +to 32 bytes, and `ValueType` from 16 to 32 bytes. `PolyValue` stays 56 bytes. +Rich scalar cloning costs much more on enum/pattern fixtures even when the +original integer/string fixture does not add allocations. + +Callgrind collects only `measured_region`, 25 operations on the 1,000-item catalog. +The [old](data/2026-10-03/runtime-optimization/diagnostics/old/read-1000-annotated.txt), +[control](data/2026-10-03/runtime-optimization/diagnostics/control/read-1000-annotated.txt), and +[retained](data/2026-10-03/runtime-optimization/diagnostics/selected/read-1000-annotated.txt) read profiles record +283,054,621, 294,910,404 and 296,585,254 instructions respectively. +The [old](data/2026-10-03/runtime-optimization/diagnostics/old/write-1000-annotated.txt), +[control](data/2026-10-03/runtime-optimization/diagnostics/control/write-1000-annotated.txt), and +[retained](data/2026-10-03/runtime-optimization/diagnostics/selected/write-1000-annotated.txt) write profiles +record 80,501,030, 88,873,605 and 73,268,130 instructions. +Cursor write-through, formatting and unnecessary list traversal suggested the +write experiments. Read instruction counts have not recovered; timing and +instruction count are separate observations. These simulated counts measure +neither hardware cycles nor latency. Instrumented allocator consumers are never +used for the Criterion tables. + +## Experiments and verification + +The [screening archive](data/2026-10-03/runtime-optimization/screening.tar.gz) retains eight cumulative +experiments, with two processes per revision, 50 samples, one-second warmup and +two-second measurement targets, plus the working-set screens. The guard-only +serializer experiment was slightly slower; field selection was approximately +neutral on plain records. The first screen retains writer data only, and no read +conclusion is drawn from it. Borrowed metadata, regex reuse, formatter changes, +append-only output and unified scalar state were then tested separately. +The [prototype confirmation archive](data/2026-10-03/runtime-optimization/prototype-confirmation.tar.gz) +preserves the earlier confirmations and contaminated attempt. Archive checksums +and file counts are in [archives.json](data/2026-10-03/runtime-optimization/archives.json). + +The [quality gate](data/2026-10-03/runtime-optimization/verification/quality-gate.txt) passes strict Clippy, +321 Rust tests and 112 Python tests with 100% statement and branch coverage. +Additional tests cover repeated/nested lexical lists, whitespace rejection, +escaping, empty lists, integer extremes, schema edits, invalid patterns, raw +restriction text versus trimmed pattern text, split Text/CData/GeneralRef, +mixed branch order, nested frames, nil reads, cache churn and concurrency. + +The refreshed [CType sample](data/2026-10-03/runtime-optimization/verification/corpus.txt) matches the +[earlier summary/group table](data/2026-10-03/runtime-optimization/verification/corpus-reference.txt) exactly: +31/31 schema expectations and 23/28 instance round trips, with five existing +failures. The earlier log lacks a source SHA; this is a recorded regression +reference, not a full W3C conformance claim. + +An extra fixture exposed escaped XSD enumeration values and nil mixed-branch +serialization limitations. A [minimal reproducer](data/2026-10-03/runtime-optimization/verification/known-limits.rs) +produces the same errors with the [control](data/2026-10-03/runtime-optimization/verification/known-limits-control.txt) +and [retained engine](data/2026-10-03/runtime-optimization/verification/known-limits-selected.txt). These remain +separate correctness work; the optimization retains their behavior. diff --git a/docs/benchmarks/rust-xml-serde-regression-2026-10.md b/docs/benchmarks/rust-xml-serde-regression-2026-10.md index cc15a04..7fa37f3 100644 --- a/docs/benchmarks/rust-xml-serde-regression-2026-10.md +++ b/docs/benchmarks/rust-xml-serde-regression-2026-10.md @@ -11,6 +11,10 @@ and **12–14% on XML writes** compared with version 0.27.0. These are separate execution paths; generated XML methods call quick-xml directly rather than building dynamic PolyValue records. +The follow-up [dynamic runtime optimization study](rust-runtime-optimization-2026-10.md) +records branch experiments and later comparisons; the figures below remain the +unoptimized release audit. + This comparison ran on October 3, 2026, between [`cef575c` (0.27.0, September 27)](https://github.com/polyxml/PolyXML/commit/cef575c11cc4f05e877ced157036f7ff53b8687b) and [`bbbd087` (0.34.6)](https://github.com/polyxml/PolyXML/commit/bbbd087a9a8e9838a32912973cd4029c30f29c08).