Auto merge of #2219 - saethlin:more-benchmarks, r=RalfJung

Add more bench-cargo-miri programs

These example programs are derived from long-running (>15 minutes) tests in the test suites of highly-downloaded crates (if I have my way, that runtime will not be correct for long). They should serve as realistic but also somewhat pathological workloads for the interpreter.

The unicode program stresses the code which looks for adjacent and equal stacks to merge them.
The backtraces program has an uncommonly large working set of borrow tags per borrow stack.

This also updates the .gitignore to ignore files commonly emitted in the course of using these benchmark programs.

---

The benchmark programs are so-named to avoid confusingly duplicating the names of the crates they are benchmarking. Is that a good idea? I started doing this so that I could use `cargo add` but now I'm not entirely sold on the names.

Author: bors

.gitignore

@@ -4,3 +4,7 @@ tex/*/out
 *.dot
 *.rs.bk
 .vscode
+*.mm_profdata
+perf.data
+perf.data.old
+flamegraph.svg

bench-cargo-miri/backtraces/Cargo.lock

@@ -0,0 +1,9 @@
+[package]
+name = "backtraces"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+backtrace = "0.3.65"

bench-cargo-miri/backtraces/Cargo.toml

@@ -0,0 +1,29 @@
+//! Extracted from the backtrace crate's test test_frame_conversion
+
+use backtrace::{Backtrace, BacktraceFrame};
+use std::fmt::Write;
+
+fn main() {
+    let mut frames = vec![];
+    backtrace::trace(|frame| {
+        let converted = BacktraceFrame::from(frame.clone());
+        frames.push(converted);
+        true
+    });
+
+    let mut manual = Backtrace::from(frames);
+    manual.resolve();
+    let frames = manual.frames();
+
+    let mut output = String::new();
+    for frame in frames {
+        // Originally these were println! but we'd prefer our benchmarks to not emit a lot of
+        // output to stdout/stderr. Unfortunately writeln! to a String is faster, but we still
+        // manage to exercise interesting code paths in Miri.
+        writeln!(output, "{:?}", frame.ip()).unwrap();
+        writeln!(output, "{:?}", frame.symbol_address()).unwrap();
+        writeln!(output, "{:?}", frame.module_base_address()).unwrap();
+        writeln!(output, "{:?}", frame.symbols()).unwrap();
+    }
+    drop(output);
+}

bench-cargo-miri/backtraces/src/main.rs

@@ -0,0 +1,9 @@
+[package]
+name = "unicode"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+unicode-xid = "0.2.3"

bench-cargo-miri/mse/Cargo.lock

@@ -0,0 +1,20 @@
+//! Extracted from the unicode-xid exhaustive test all_valid_chars_do_not_panic_for_is_xid_continue
+
+use unicode_xid::UnicodeXID;
+
+/// A `char` in Rust is a Unicode Scalar Value
+///
+/// See: http://www.unicode.org/glossary/#unicode_scalar_value
+fn all_valid_chars() -> impl Iterator<Item = char> {
+    (0u32..=0xD7FF).chain(0xE000u32..=0x10FFFF).map(|u| {
+        core::convert::TryFrom::try_from(u)
+            .expect("The selected range should be infallible if the docs match impl")
+    })
+}
+
+fn main() {
+    // Take only the first few chars because we don't want to wait all day
+    for c in all_valid_chars().take(2_000) {
+        let _ = UnicodeXID::is_xid_continue(c);
+    }
+}