diff --git a/README.md b/README.md index 6c3f6bd8..778dd683 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ Speedily search and merge log messages by datetime. [![crates.io version](https://img.shields.io/crates/v/super-speedy-syslog-searcher.svg?style=flat-square&logo=rust&logoColor=800000?branch=0.6.69&version=0.6.71)](https://crates.io/crates/super-speedy-syslog-searcher/0.6.71) [![crates.io downloads](https://img.shields.io/crates/d/super-speedy-syslog-searcher.svg?style=flat-square&logo=rust&logoColor=800000&version=0.6.71)](https://crates.io/crates/super-speedy-syslog-searcher/0.6.71) -[![coveralls.io](https://img.shields.io/coverallsCoverage/github/jtmoon79/super-speedy-syslog-searcher?style=flat-square&logo=coveralls&logoColor=b94947&branch=0.6.70&version=0.6.70)](https://coveralls.io/github/jtmoon79/super-speedy-syslog-searcher?branch=0.6.71) +[![coveralls.io](https://img.shields.io/coverallsCoverage/github/jtmoon79/super-speedy-syslog-searcher?style=flat-square&logo=coveralls&logoColor=b94947&branch=0.6.71&version=0.6.71)](https://coveralls.io/github/jtmoon79/super-speedy-syslog-searcher?branch=0.6.71) [![Commits since](https://img.shields.io/github/commits-since/jtmoon79/super-speedy-syslog-searcher/0.6.71.svg)](https://github.com/jtmoon79/super-speedy-syslog-searcher/commits/main) _Super Speedy Syslog Searcher_ (`s4`) is a command-line tool to search @@ -530,18 +530,24 @@ A comparison of merging three large log files: - 2500 line log file, 1078842 bytes (≈1.0 MB), with high-plane unicode - 5000 line log file, 2158138 bytes (≈2.1 MB), with high-plane unicode -This informal runtime comparison used GNU `time` running on Ubuntu 22 on WSL2. - |Program |real|user|sys | |- |- |- |- | -|`grep \| sort`|0.05|0.04|0.00| -|`s4` |0.05|0.05|0.02| -|`logmerger` |0.83|0.79|0.01| +|`grep \| sort`|0.04|0.04|0.00| +|`s4` |0.04|0.03|0.04| +|`logmerger` |0.78|0.74|0.00| +|`tl` |0.94|0.55|0.06| + +This informal runtime comparison used GNU `time` running on Ubuntu 22 on WSL2. + +- `grep` 3.7, `sort` 8.32 +- `s4` 0.6.71 +- `logmerger` 0.8.0 on Python 3.10.12 +- `tl` 1.4.0 on Python 3.10.12 See directory [compare-log-mergers] and results in [`compare-log-mergers.txt`]. [compare-log-mergers]: ./tools/compare-log-mergers/ -[`compare-log-mergers.txt`]: ./releases/0.6.70/compare-log-mergers.txt +[`compare-log-mergers.txt`]: ./releases/0.6.71/compare-log-mergers.txt --- diff --git a/releases/0.6.71/compare-log-mergers.txt b/releases/0.6.71/compare-log-mergers.txt new file mode 100644 index 00000000..654dd13d --- /dev/null +++ b/releases/0.6.71/compare-log-mergers.txt @@ -0,0 +1,50 @@ ++ /usr/bin/time --version +time (GNU Time) UNKNOWN ++ python --version +Python 3.10.12 +---------------------------------------- ++ /usr/bin/grep --version +grep (GNU grep) 3.7 ++ /usr/bin/sort --version +sort (GNU coreutils) 8.32 + ++ /usr/bin/time -p -- bash -c '/usr/bin/grep -hEe '\''^2000-01-01T00\:([234][[:digit:]]\:[[:digit:]]{2}|50\:00)'\'' -- ./tools/compare-log-mergers/gen-5000-1-faces.log ./tools/compare-log-mergers/gen-2500-1-faces.log ./tools/compare-log-mergers/gen-2000-1-faces.log | /usr/bin/sort -t '\'' '\'' -k 1 -s > '\''/tmp/compare-log-mergers_0PxOK.out'\''' +real 0.04 +user 0.04 +sys 0.00 + +4403 /tmp/compare-log-mergers_0PxOK.out +---------------------------------------- ++ ./target/release/s4 --version +super_speedy_syslog_searcher 0.6.71 + ++ /usr/bin/time -p -- ./target/release/s4 -a 2000-01-01T00:20:00 -b 2000-01-01T00:50:00 --color=never ./tools/compare-log-mergers/gen-5000-1-faces.log ./tools/compare-log-mergers/gen-2500-1-faces.log ./tools/compare-log-mergers/gen-2000-1-faces.log +real 0.04 +user 0.03 +sys 0.04 + +4403 /tmp/compare-log-mergers_0PxOK.out +---------------------------------------- ++ logmerger --version +logmerger 0.8.0 + ++ /usr/bin/time -p -- logmerger --inline --output=- --start 2000-01-01T00:20:00 --end 2000-01-01T00:50:00 ./tools/compare-log-mergers/gen-5000-1-faces.log ./tools/compare-log-mergers/gen-2500-1-faces.log ./tools/compare-log-mergers/gen-2000-1-faces.log +real 0.78 +user 0.74 +sys 0.00 + +4908 /tmp/compare-log-mergers_0PxOK.out +---------------------------------------- ++ logdissect --version +logdissect 3.1.1 + +TODO: figure out how to use logdissect. I'm unable to get it to match on ANY files. + +---------------------------------------- ++ tl --version +tl, version 1.4.0 + ++ /usr/bin/time -p -- tl --merge --output-merge=/tmp/compare-log-mergers_0PxOK.out ./tools/compare-log-mergers/gen-5000-1-faces.log ./tools/compare-log-mergers/gen-2500-1-faces.log ./tools/compare-log-mergers/gen-2000-1-faces.log +real 0.94 +user 0.55 +sys 0.06 \ No newline at end of file diff --git a/releases/0.6.71/flamegraph-evtx.svg b/releases/0.6.71/flamegraph-evtx.svg new file mode 100644 index 00000000..22877871 --- /dev/null +++ b/releases/0.6.71/flamegraph-evtx.svg @@ -0,0 +1,4287 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 5000; created 20240415T235629-0700
; s4 ./logs/programs/evtx/Microsoft-Windows-Kernel-PnP%4Configuration.evtx + + Reset Zoom + Search + + + + _dl_unload_cache (1 samples, 0.25%) + + + + + munmap (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + _dl_relocate_object (2 samples, 0.50%) + + + + + elf_dynamic_do_Rela (2 samples, 0.50%) + + + + + elf_machine_rela_relative (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + _dl_start (4 samples, 1.00%) + + + + + _dl_start_final (4 samples, 1.00%) + + + + + _dl_sysdep_start (4 samples, 1.00%) + + + + + dl_main (4 samples, 1.00%) + + + + + _dl_map_object_deps (1 samples, 0.25%) + + + + + _dl_catch_exception (1 samples, 0.25%) + + + + + openaux (1 samples, 0.25%) + + + + + _dl_map_object (1 samples, 0.25%) + + + + + _dl_map_object_from_fd (1 samples, 0.25%) + + + + + _dl_map_segments (1 samples, 0.25%) + + + + + __mmap64 (1 samples, 0.25%) + + + + + __mmap64 (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + s4::processing_loop (1 samples, 0.25%) + + + + + s4::processing_loop::recv_many_chan (1 samples, 0.25%) + + + + + crossbeam_channel::select::Select::select (1 samples, 0.25%) + + + + + s4::string_wdhms_to_duration (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__stability (1 samples, 0.25%) + + + + + lazy_static::lazy::Lazy<T>::get (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once (1 samples, 0.25%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 0.25%) + + + + + lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.25%) + + + + + core::ops::function::FnOnce::call_once (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.25%) + + + + + regex::regex::string::Regex::new (1 samples, 0.25%) + + + + + regex::builders::string::RegexBuilder::build (1 samples, 0.25%) + + + + + regex::builders::Builder::build_one_string (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::Parser::parse (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_with_comments (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_group (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_group (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::bump (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.25%) + + + + + regex_syntax::ast::parse::ParserI<P>::char_at (1 samples, 0.25%) + + + + + <core::str::iter::Chars as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::str::validations::next_code_point (1 samples, 0.25%) + + + + + main (3 samples, 0.75%) + + + + + std::rt::lang_start_internal (3 samples, 0.75%) + + + + + std::panic::catch_unwind (3 samples, 0.75%) + + + + + std::panicking::try (3 samples, 0.75%) + + + + + std::panicking::try::do_call (3 samples, 0.75%) + + + + + std::rt::lang_start_internal::{{closure}} (3 samples, 0.75%) + + + + + std::panic::catch_unwind (3 samples, 0.75%) + + + + + std::panicking::try (3 samples, 0.75%) + + + + + std::panicking::try::do_call (3 samples, 0.75%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (3 samples, 0.75%) + + + + + std::rt::lang_start::{{closure}} (3 samples, 0.75%) + + + + + std::sys_common::backtrace::__rust_begin_short_backtrace (3 samples, 0.75%) + + + + + core::ops::function::FnOnce::call_once (3 samples, 0.75%) + + + + + s4::main (3 samples, 0.75%) + + + + + s4::cli_process_args (2 samples, 0.50%) + + + + + clap_builder::derive::Parser::parse (1 samples, 0.25%) + + + + + <s4::CLI_Args as clap_builder::derive::CommandFactory>::command (1 samples, 0.25%) + + + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 0.25%) + + + + + __rust_probestack (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + _start (9 samples, 2.24%) + + _.. + + + __libc_start_main_impl (5 samples, 1.24%) + + + + + __libc_start_call_main (5 samples, 1.24%) + + + + + __GI_exit (2 samples, 0.50%) + + + + + __run_exit_handlers (2 samples, 0.50%) + + + + + __GI__exit (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + __clone3 (1 samples, 0.25%) + + + + + start_thread (1 samples, 0.25%) + + + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 0.25%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.25%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.25%) + + + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1 samples, 0.25%) + + + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1 samples, 0.25%) + + + + + std::sys::unix::thread::Thread::set_name (1 samples, 0.25%) + + + + + __pthread_setname_np (1 samples, 0.25%) + + + + + __GI___prctl (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + s4::cli_process_args (1 samples, 0.25%) + + + + + s4::string_wdhms_to_duration (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__stability (1 samples, 0.25%) + + + + + lazy_static::lazy::Lazy<T>::get (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once (1 samples, 0.25%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 0.25%) + + + + + lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.25%) + + + + + core::ops::function::FnOnce::call_once (1 samples, 0.25%) + + + + + <s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.25%) + + + + + regex::regex::string::Regex::new (1 samples, 0.25%) + + + + + regex::builders::string::RegexBuilder::build (1 samples, 0.25%) + + + + + regex::builders::Builder::build_one_string (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.25%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.25%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::nfa::Inner::add (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.25%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.25%) + + + + + alloc::alloc::realloc (1 samples, 0.25%) + + + + + __GI___libc_realloc (1 samples, 0.25%) + + + + + _int_realloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + sysmalloc (1 samples, 0.25%) + + + + + __glibc_morecore (1 samples, 0.25%) + + + + + __GI___sbrk (1 samples, 0.25%) + + + + + __GI___sbrk (1 samples, 0.25%) + + + + + __brk (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.25%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.25%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.25%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 0.25%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.25%) + + + + + alloc::vec::from_elem (1 samples, 0.25%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.25%) + + + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (1 samples, 0.25%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (1 samples, 0.25%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (1 samples, 0.25%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.25%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.25%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.25%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.25%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.25%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.25%) + + + + + [unknown] (3 samples, 0.75%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.25%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (1 samples, 0.25%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (1 samples, 0.25%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (1 samples, 0.25%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (1 samples, 0.25%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (1 samples, 0.25%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.25%) + + + + + __GI___libc_write (1 samples, 0.25%) + + + + + __GI___libc_write (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + s4 (24 samples, 5.97%) + + s4 + + + [[kernel.kallsyms]] (11 samples, 2.74%) + + [[.. + + + [[kernel.kallsyms]] (11 samples, 2.74%) + + [[.. + + + [[kernel.kallsyms]] (11 samples, 2.74%) + + [[.. + + + [[kernel.kallsyms]] (11 samples, 2.74%) + + [[.. + + + perf-exec (10 samples, 2.49%) + + pe.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (8 samples, 1.99%) + + [.. + + + [[kernel.kallsyms]] (8 samples, 1.99%) + + [.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (12 samples, 2.99%) + + [[k.. + + + __GI___mprotect (13 samples, 3.23%) + + __G.. + + + [[kernel.kallsyms]] (13 samples, 3.23%) + + [[k.. + + + [[kernel.kallsyms]] (13 samples, 3.23%) + + [[k.. + + + [[kernel.kallsyms]] (13 samples, 3.23%) + + [[k.. + + + [[kernel.kallsyms]] (13 samples, 3.23%) + + [[k.. + + + [[kernel.kallsyms]] (13 samples, 3.23%) + + [[k.. + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (4 samples, 1.00%) + + + + + [[kernel.kallsyms]] (4 samples, 1.00%) + + + + + std::sys::unix::stack_overflow::Handler::new (19 samples, 4.73%) + + std::s.. + + + std::sys::unix::stack_overflow::imp::make_handler (19 samples, 4.73%) + + std::s.. + + + std::sys::unix::stack_overflow::imp::get_stack (19 samples, 4.73%) + + std::s.. + + + std::sys::unix::stack_overflow::imp::get_stackp (19 samples, 4.73%) + + std::s.. + + + __GI___mmap64 (6 samples, 1.49%) + + + + + __GI___mmap64 (6 samples, 1.49%) + + + + + [[kernel.kallsyms]] (6 samples, 1.49%) + + + + + [[kernel.kallsyms]] (6 samples, 1.49%) + + + + + [[kernel.kallsyms]] (6 samples, 1.49%) + + + + + [[kernel.kallsyms]] (6 samples, 1.49%) + + + + + [[kernel.kallsyms]] (6 samples, 1.49%) + + + + + std::sys::unix::stack_overflow::imp::make_handler (1 samples, 0.25%) + + + + + __GI___sigaltstack (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + __GI___munmap (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + __GI___mprotect (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [unknown] (1 samples, 0.25%) + + + + + std::sys::unix::thread::guard::current (4 samples, 1.00%) + + + + + __pthread_getattr_np (4 samples, 1.00%) + + + + + __GI___libc_malloc (4 samples, 1.00%) + + + + + tcache_init (4 samples, 1.00%) + + + + + tcache_init (4 samples, 1.00%) + + + + + arena_get2 (4 samples, 1.00%) + + + + + arena_get2 (4 samples, 1.00%) + + + + + _int_new_arena (4 samples, 1.00%) + + + + + new_heap (4 samples, 1.00%) + + + + + alloc_new_heap (4 samples, 1.00%) + + + + + __GI___mmap64 (2 samples, 0.50%) + + + + + __GI___mmap64 (2 samples, 0.50%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + s4lib::readers::evtxreader::EvtxReader::new (1 samples, 0.25%) + + + + + evtx::evtx_parser::ParserSettings::num_threads (1 samples, 0.25%) + + + + + rayon_core::current_num_threads (1 samples, 0.25%) + + + + + rayon_core::registry::Registry::current_num_threads (1 samples, 0.25%) + + + + + rayon_core::registry::global_registry (1 samples, 0.25%) + + + + + rayon_core::registry::set_global_registry (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once (1 samples, 0.25%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 0.25%) + + + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 0.25%) + + + + + rayon_core::registry::set_global_registry::{{closure}} (1 samples, 0.25%) + + + + + core::ops::function::FnOnce::call_once (1 samples, 0.25%) + + + + + rayon_core::registry::default_global_registry (1 samples, 0.25%) + + + + + rayon_core::registry::Registry::new (1 samples, 0.25%) + + + + + <rayon_core::registry::DefaultSpawn as rayon_core::registry::ThreadSpawn>::spawn (1 samples, 0.25%) + + + + + std::thread::Builder::spawn (1 samples, 0.25%) + + + + + std::thread::Builder::spawn_unchecked (1 samples, 0.25%) + + + + + std::thread::Builder::spawn_unchecked_ (1 samples, 0.25%) + + + + + std::sys::unix::thread::Thread::new (1 samples, 0.25%) + + + + + __pthread_create_2_1 (1 samples, 0.25%) + + + + + allocate_stack (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + s4lib::data::evtx::Evtx::from_evtxrs (1 samples, 0.25%) + + + + + <alloc::string::String as core::ops::arith::Add<&str>>::add (1 samples, 0.25%) + + + + + alloc::string::String::push_str (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.25%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.25%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.25%) + + + + + alloc::alloc::realloc (1 samples, 0.25%) + + + + + __GI___libc_realloc (1 samples, 0.25%) + + + + + _int_realloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + sysmalloc (1 samples, 0.25%) + + + + + grow_heap (1 samples, 0.25%) + + + + + __GI___mprotect (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + std::io::Read::read_to_end (5 samples, 1.24%) + + + + + std::io::default_read_to_end (5 samples, 1.24%) + + + + + <std::io::Take<T> as std::io::Read>::read_buf (5 samples, 1.24%) + + + + + std::io::impls::<impl std::io::Read for &mut R>::read_buf (5 samples, 1.24%) + + + + + <std::fs::File as std::io::Read>::read_buf (5 samples, 1.24%) + + + + + std::sys::unix::fs::File::read_buf (5 samples, 1.24%) + + + + + std::sys::unix::fd::FileDesc::read_buf (5 samples, 1.24%) + + + + + __GI___libc_read (5 samples, 1.24%) + + + + + __GI___libc_read (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + [[kernel.kallsyms]] (5 samples, 1.24%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (15 samples, 3.73%) + + <cor.. + + + s4lib::readers::evtxreader::EvtxReader::analyze (33 samples, 8.21%) + + s4lib::read.. + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <core::iter.. + + + <core::iter::adapters::flatten::Flatten<I> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <core::iter.. + + + <core::iter::adapters::flatten::FlattenCompat<I,U> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <core::iter.. + + + <core::iter::adapters::fuse::Fuse<I> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <core::iter.. + + + <core::iter::adapters::fuse::Fuse<I> as core::iter::adapters::fuse::FuseImpl<I>>::next (32 samples, 7.96%) + + <core::iter.. + + + core::iter::adapters::fuse::and_then_or_clear (32 samples, 7.96%) + + core::iter:.. + + + core::ops::function::FnOnce::call_once (32 samples, 7.96%) + + core::ops::.. + + + <core::iter::sources::from_fn::FromFn<F> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <core::iter.. + + + evtx::evtx_parser::EvtxParser<T>::serialized_records::{{closure}} (32 samples, 7.96%) + + evtx::evtx_.. + + + <evtx::evtx_parser::IterChunks<T> as core::iter::traits::iterator::Iterator>::next (32 samples, 7.96%) + + <evtx::evtx.. + + + evtx::evtx_parser::EvtxParser<T>::find_next_chunk (32 samples, 7.96%) + + evtx::evtx_.. + + + evtx::evtx_parser::EvtxParser<T>::allocate_chunk (32 samples, 7.96%) + + evtx::evtx_.. + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::all (27 samples, 6.72%) + + <core::sl.. + + + s4::processing_loop::{{closure}} (35 samples, 8.71%) + + s4::processi.. + + + s4::exec_fileprocessor_thread (35 samples, 8.71%) + + s4::exec_fil.. + + + s4::exec_evtxprocessor (35 samples, 8.71%) + + s4::exec_evt.. + + + s4::chan_send (1 samples, 0.25%) + + + + + crossbeam_channel::channel::Sender<T>::send (1 samples, 0.25%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send (1 samples, 0.25%) + + + + + crossbeam_utils::backoff::Backoff::snooze (1 samples, 0.25%) + + + + + core::hint::spin_loop (1 samples, 0.25%) + + + + + core::core_arch::x86::sse2::_mm_pause (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (50 samples, 12.44%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (104 samples, 25.87%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (126 samples, 31.34%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (159 samples, 39.55%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (159 samples, 39.55%) + + [[kernel.kallsyms]] + + + rayon_core::sleep::Sleep::no_work_found (160 samples, 39.80%) + + rayon_core::sleep::Sleep::no_work_found + + + rayon_core::sleep::Sleep::sleep (160 samples, 39.80%) + + rayon_core::sleep::Sleep::sleep + + + std::sync::condvar::Condvar::wait (160 samples, 39.80%) + + std::sync::condvar::Condvar::wait + + + std::sys::unix::locks::futex_condvar::Condvar::wait (160 samples, 39.80%) + + std::sys::unix::locks::futex_condvar::Condvar::wait + + + std::sys::unix::locks::futex_condvar::Condvar::wait_optional_timeout (160 samples, 39.80%) + + std::sys::unix::locks::futex_condvar::Condvar::wait_optional_time.. + + + std::sys::unix::futex::futex_wait (160 samples, 39.80%) + + std::sys::unix::futex::futex_wait + + + syscall (160 samples, 39.80%) + + syscall + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (160 samples, 39.80%) + + [[kernel.kallsyms]] + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}} (1 samples, 0.25%) + + + + + core::result::Result<T,E>::and_then (1 samples, 0.25%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}}::{{closure}} (1 samples, 0.25%) + + + + + evtx::evtx_record::EvtxRecord::into_xml (1 samples, 0.25%) + + + + + evtx::evtx_record::EvtxRecord::into_output (1 samples, 0.25%) + + + + + evtx::binxml::assemble::parse_tokens (1 samples, 0.25%) + + + + + <evtx::xml_output::XmlOutput<W> as evtx::xml_output::BinXmlOutput>::visit_open_start_element (1 samples, 0.25%) + + + + + evtx::binxml::value_variant::BinXmlValue::as_cow_str (1 samples, 0.25%) + + + + + <T as alloc::string::ToString>::to_string (1 samples, 0.25%) + + + + + <chrono::format::formatting::DelayedFormat<I> as core::fmt::Display>::fmt (1 samples, 0.25%) + + + + + chrono::format::formatting::DelayedFormat<I>::format (1 samples, 0.25%) + + + + + chrono::format::formatting::DelayedFormat<I>::format_numeric (1 samples, 0.25%) + + + + + chrono::format::formatting::DelayedFormat<I>::format_numeric::write_two (1 samples, 0.25%) + + + + + <alloc::string::String as core::fmt::Write>::write_char (1 samples, 0.25%) + + + + + alloc::string::String::push (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.25%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.25%) + + + + + alloc::alloc::realloc (1 samples, 0.25%) + + + + + __GI___libc_realloc (1 samples, 0.25%) + + + + + _int_realloc (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_template (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_token_substitution (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_template (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::model::xml::XmlElementBuilder::finish (1 samples, 0.25%) + + + + + evtx::model::xml::XmlElementBuilder::attribute_value (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + __GI___libc_malloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + sysmalloc (1 samples, 0.25%) + + + + + grow_heap (1 samples, 0.25%) + + + + + __GI___mprotect (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + core::option::Option<T>::map (4 samples, 1.00%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 1.00%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}} (4 samples, 1.00%) + + + + + core::result::Result<T,E>::and_then (4 samples, 1.00%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}}::{{closure}} (4 samples, 1.00%) + + + + + evtx::evtx_record::EvtxRecord::into_xml (4 samples, 1.00%) + + + + + evtx::evtx_record::EvtxRecord::into_output (4 samples, 1.00%) + + + + + evtx::binxml::assemble::parse_tokens (4 samples, 1.00%) + + + + + evtx::binxml::assemble::create_record_model (3 samples, 0.75%) + + + + + alloc::vec::Vec<T>::with_capacity (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.25%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.25%) + + + + + alloc::alloc::alloc (1 samples, 0.25%) + + + + + __GI___libc_malloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + sysmalloc (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + rayon_core::registry::Registry::in_worker_cold::{{closure}}::{{closure}} (6 samples, 1.49%) + + + + + rayon_core::join::join_context::{{closure}} (6 samples, 1.49%) + + + + + rayon_core::unwind::halt_unwinding (6 samples, 1.49%) + + + + + std::panic::catch_unwind (6 samples, 1.49%) + + + + + std::panicking::try (6 samples, 1.49%) + + + + + std::panicking::try::do_call (6 samples, 1.49%) + + + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (6 samples, 1.49%) + + + + + rayon_core::join::join_context::call_a::{{closure}} (6 samples, 1.49%) + + + + + rayon::iter::plumbing::bridge_producer_consumer::helper::{{closure}} (6 samples, 1.49%) + + + + + rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 1.49%) + + + + + rayon::iter::plumbing::Producer::fold_with (6 samples, 1.49%) + + + + + <rayon::iter::map::MapFolder<C,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 1.49%) + + + + + rayon::iter::plumbing::Folder::consume_iter (6 samples, 1.49%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (6 samples, 1.49%) + + + + + core::option::Option<T>::map (6 samples, 1.49%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (6 samples, 1.49%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &F>::call_mut (6 samples, 1.49%) + + + + + evtx::evtx_parser::EvtxParser<T>::serialized_records::{{closure}}::{{closure}} (6 samples, 1.49%) + + + + + core::iter::traits::iterator::Iterator::collect (6 samples, 1.49%) + + + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (6 samples, 1.49%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (6 samples, 1.49%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (6 samples, 1.49%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (5 samples, 1.24%) + + + + + alloc::vec::Vec<T,A>::extend_desugared (5 samples, 1.24%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (5 samples, 1.24%) + + + + + <evtx::evtx_chunk::IterChunkRecords as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + <evtx::binxml::deserializer::IterTokens as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::inner_next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::visit_token (1 samples, 0.25%) + + + + + evtx::binxml::tokens::read_template (1 samples, 0.25%) + + + + + evtx::binxml::value_variant::BinXmlValue::deserialize_value_type (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::BinXmlDeserializer::read_binxml_fragment (1 samples, 0.25%) + + + + + <evtx::binxml::deserializer::IterTokens as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::inner_next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::visit_token (1 samples, 0.25%) + + + + + evtx::binxml::tokens::read_template (1 samples, 0.25%) + + + + + evtx::binxml::value_variant::BinXmlValue::deserialize_value_type (1 samples, 0.25%) + + + + + evtx::utils::binxml_utils::read_utf16_by_size (1 samples, 0.25%) + + + + + evtx::utils::binxml_utils::read_utf16_string (1 samples, 0.25%) + + + + + core::iter::traits::iterator::Iterator::collect (1 samples, 0.25%) + + + + + <core::result::Result<V,E> as core::iter::traits::collect::FromIterator<core::result::Result<A,E>>>::from_iter (1 samples, 0.25%) + + + + + core::iter::adapters::try_process (1 samples, 0.25%) + + + + + <core::result::Result<V,E> as core::iter::traits::collect::FromIterator<core::result::Result<A,E>>>::from_iter::{{closure}} (1 samples, 0.25%) + + + + + core::iter::traits::iterator::Iterator::collect (1 samples, 0.25%) + + + + + <alloc::string::String as core::iter::traits::collect::FromIterator<char>>::from_iter (1 samples, 0.25%) + + + + + <alloc::string::String as core::iter::traits::collect::Extend<char>>::extend (1 samples, 0.25%) + + + + + core::iter::traits::iterator::Iterator::for_each (1 samples, 0.25%) + + + + + <core::iter::adapters::GenericShunt<I,R> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.25%) + + + + + <core::iter::adapters::GenericShunt<I,R> as core::iter::traits::iterator::Iterator>::try_fold (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::try_fold (1 samples, 0.25%) + + + + + core::iter::traits::iterator::Iterator::try_fold (1 samples, 0.25%) + + + + + core::iter::adapters::map::map_try_fold::{{closure}} (1 samples, 0.25%) + + + + + <core::iter::adapters::GenericShunt<I,R> as core::iter::traits::iterator::Iterator>::try_fold::{{closure}} (1 samples, 0.25%) + + + + + <core::const_closure::ConstFnMutClosure<&mut A,Function> as core::ops::function::FnMut<ClosureArguments>>::call_mut (1 samples, 0.25%) + + + + + core::ops::function::Fn::call (1 samples, 0.25%) + + + + + core::ops::try_trait::NeverShortCircuit<T>::wrap_mut_2_imp (1 samples, 0.25%) + + + + + core::iter::traits::iterator::Iterator::for_each::call::{{closure}} (1 samples, 0.25%) + + + + + <alloc::string::String as core::iter::traits::collect::Extend<char>>::extend::{{closure}} (1 samples, 0.25%) + + + + + alloc::string::String::push (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::expand_template (1 samples, 0.25%) + + + + + evtx::binxml::assemble::_expand_templates (1 samples, 0.25%) + + + + + evtx::binxml::assemble::create_record_model (1 samples, 0.25%) + + + + + evtx::model::xml::XmlElementBuilder::finish (1 samples, 0.25%) + + + + + core::option::Option<T>::ok_or (1 samples, 0.25%) + + + + + quick_xml::writer::Writer<W>::write_event (1 samples, 0.25%) + + + + + quick_xml::writer::Writer<W>::write_wrapped (1 samples, 0.25%) + + + + + quick_xml::writer::Writer<W>::write (1 samples, 0.25%) + + + + + std::io::impls::<impl std::io::Write for alloc::vec::Vec<u8,A>>::write_all (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.25%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.25%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.25%) + + + + + alloc::alloc::realloc (1 samples, 0.25%) + + + + + __GI___libc_realloc (1 samples, 0.25%) + + + + + _int_realloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.25%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.25%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.25%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.25%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.25%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.25%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.25%) + + + + + alloc::alloc::realloc (1 samples, 0.25%) + + + + + __GI___libc_realloc (1 samples, 0.25%) + + + + + _int_realloc (1 samples, 0.25%) + + + + + _int_malloc (1 samples, 0.25%) + + + + + <evtx::xml_output::XmlOutput<W> as evtx::xml_output::BinXmlOutput>::visit_open_start_element (3 samples, 0.75%) + + + + + quick_xml::events::BytesStart::push_attribute (2 samples, 0.50%) + + + + + <evtx::xml_output::XmlOutput<W> as evtx::xml_output::BinXmlOutput>::visit_close_element (1 samples, 0.25%) + + + + + evtx::binxml::name::BinXmlName::as_str (1 samples, 0.25%) + + + + + <alloc::string::String as core::ops::deref::Deref>::deref (1 samples, 0.25%) + + + + + evtx::binxml::assemble::parse_tokens (7 samples, 1.74%) + + + + + <evtx::xml_output::XmlOutput<W> as evtx::xml_output::BinXmlOutput>::visit_characters (1 samples, 0.25%) + + + + + evtx::binxml::value_variant::BinXmlValue::as_cow_str (1 samples, 0.25%) + + + + + evtx::evtx_record::EvtxRecord::into_output (8 samples, 1.99%) + + e.. + + + core::ptr::drop_in_place<alloc::sync::Arc<evtx::evtx_parser::ParserSettings>> (1 samples, 0.25%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.25%) + + + + + core::option::Option<T>::map (9 samples, 2.24%) + + c.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (9 samples, 2.24%) + + c.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &F>::call_mut (9 samples, 2.24%) + + c.. + + + evtx::evtx_parser::EvtxParser<T>::serialized_records::{{closure}}::{{closure}} (9 samples, 2.24%) + + e.. + + + core::iter::traits::iterator::Iterator::collect (9 samples, 2.24%) + + c.. + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (9 samples, 2.24%) + + <.. + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (9 samples, 2.24%) + + <.. + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (9 samples, 2.24%) + + <.. + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (9 samples, 2.24%) + + <.. + + + alloc::vec::Vec<T,A>::extend_desugared (9 samples, 2.24%) + + a.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (9 samples, 2.24%) + + <.. + + + core::option::Option<T>::map (9 samples, 2.24%) + + c.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (9 samples, 2.24%) + + c.. + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}} (9 samples, 2.24%) + + e.. + + + core::result::Result<T,E>::and_then (9 samples, 2.24%) + + c.. + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}}::{{closure}} (9 samples, 2.24%) + + e.. + + + evtx::evtx_record::EvtxRecord::into_xml (9 samples, 2.24%) + + e.. + + + core::result::Result<T,E>::map_err (1 samples, 0.25%) + + + + + rayon_core::join::join_context (10 samples, 2.49%) + + ra.. + + + rayon_core::registry::in_worker (10 samples, 2.49%) + + ra.. + + + rayon_core::join::join_context::{{closure}} (10 samples, 2.49%) + + ra.. + + + rayon_core::unwind::halt_unwinding (10 samples, 2.49%) + + ra.. + + + std::panic::catch_unwind (10 samples, 2.49%) + + st.. + + + std::panicking::try (10 samples, 2.49%) + + st.. + + + std::panicking::try::do_call (10 samples, 2.49%) + + st.. + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (10 samples, 2.49%) + + <c.. + + + rayon_core::join::join_context::call_a::{{closure}} (10 samples, 2.49%) + + ra.. + + + rayon::iter::plumbing::bridge_producer_consumer::helper::{{closure}} (10 samples, 2.49%) + + ra.. + + + rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 2.49%) + + ra.. + + + rayon::iter::plumbing::Producer::fold_with (10 samples, 2.49%) + + ra.. + + + <rayon::iter::map::MapFolder<C,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (10 samples, 2.49%) + + <r.. + + + rayon::iter::plumbing::Folder::consume_iter (10 samples, 2.49%) + + ra.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (10 samples, 2.49%) + + <c.. + + + <core::iter::adapters::zip::Zip<A,B> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + <core::iter::adapters::zip::Zip<A,B> as core::iter::adapters::zip::ZipImpl<A,B>>::next (1 samples, 0.25%) + + + + + <core::option::Option<T> as core::ops::try_trait::Try>::branch (1 samples, 0.25%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + core::option::Option<T>::map (1 samples, 0.25%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.25%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}} (1 samples, 0.25%) + + + + + core::result::Result<T,E>::and_then (1 samples, 0.25%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}}::{{closure}} (1 samples, 0.25%) + + + + + evtx::evtx_record::EvtxRecord::into_xml (1 samples, 0.25%) + + + + + evtx::evtx_record::EvtxRecord::into_output (1 samples, 0.25%) + + + + + evtx::binxml::assemble::parse_tokens (1 samples, 0.25%) + + + + + evtx::binxml::assemble::create_record_model (1 samples, 0.25%) + + + + + evtx::binxml::assemble::create_record_model (2 samples, 0.50%) + + + + + core::option::Option<T>::map (3 samples, 0.75%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 0.75%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}} (3 samples, 0.75%) + + + + + core::result::Result<T,E>::and_then (3 samples, 0.75%) + + + + + evtx::evtx_parser::EvtxParser<T>::records::{{closure}}::{{closure}} (3 samples, 0.75%) + + + + + evtx::evtx_record::EvtxRecord::into_xml (3 samples, 0.75%) + + + + + evtx::evtx_record::EvtxRecord::into_output (3 samples, 0.75%) + + + + + evtx::binxml::assemble::parse_tokens (3 samples, 0.75%) + + + + + start_thread (240 samples, 59.70%) + + start_thread + + + std::sys::unix::thread::Thread::new::thread_start (240 samples, 59.70%) + + std::sys::unix::thread::Thread::new::thread_start + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (221 samples, 54.98%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (221 samples, 54.98%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (220 samples, 54.73%) + + core::ops::function::FnOnce::call_once{{vtable.shim}} + + + std::thread::Builder::spawn_unchecked_::{{closure}} (220 samples, 54.73%) + + std::thread::Builder::spawn_unchecked_::{{closure}} + + + std::panic::catch_unwind (216 samples, 53.73%) + + std::panic::catch_unwind + + + std::panicking::try (216 samples, 53.73%) + + std::panicking::try + + + std::panicking::try::do_call (216 samples, 53.73%) + + std::panicking::try::do_call + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (216 samples, 53.73%) + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_.. + + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} (216 samples, 53.73%) + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} + + + std::sys_common::backtrace::__rust_begin_short_backtrace (216 samples, 53.73%) + + std::sys_common::backtrace::__rust_begin_short_backtrace + + + <rayon_core::registry::DefaultSpawn as rayon_core::registry::ThreadSpawn>::spawn::{{closure}} (181 samples, 45.02%) + + <rayon_core::registry::DefaultSpawn as rayon_core::registry::ThreadSpawn>:.. + + + rayon_core::registry::ThreadBuilder::run (181 samples, 45.02%) + + rayon_core::registry::ThreadBuilder::run + + + rayon_core::registry::main_loop (181 samples, 45.02%) + + rayon_core::registry::main_loop + + + rayon_core::registry::WorkerThread::wait_until_out_of_work (181 samples, 45.02%) + + rayon_core::registry::WorkerThread::wait_until_out_of_work + + + rayon_core::registry::WorkerThread::wait_until (181 samples, 45.02%) + + rayon_core::registry::WorkerThread::wait_until + + + rayon_core::registry::WorkerThread::wait_until_cold (181 samples, 45.02%) + + rayon_core::registry::WorkerThread::wait_until_cold + + + rayon_core::registry::WorkerThread::execute (21 samples, 5.22%) + + rayon_.. + + + rayon_core::job::JobRef::execute (21 samples, 5.22%) + + rayon_.. + + + <rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (21 samples, 5.22%) + + <rayon.. + + + rayon_core::job::JobResult<T>::call (21 samples, 5.22%) + + rayon_.. + + + rayon_core::unwind::halt_unwinding (21 samples, 5.22%) + + rayon_.. + + + std::panic::catch_unwind (21 samples, 5.22%) + + std::p.. + + + std::panicking::try (21 samples, 5.22%) + + std::p.. + + + std::panicking::try::do_call (21 samples, 5.22%) + + std::p.. + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (21 samples, 5.22%) + + <core:.. + + + rayon_core::job::JobResult<T>::call::{{closure}} (21 samples, 5.22%) + + rayon_.. + + + rayon_core::join::join_context::call_b::{{closure}} (15 samples, 3.73%) + + rayo.. + + + rayon::iter::plumbing::bridge_producer_consumer::helper::{{closure}} (15 samples, 3.73%) + + rayo.. + + + rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 3.73%) + + rayo.. + + + rayon::iter::plumbing::Producer::fold_with (5 samples, 1.24%) + + + + + <rayon::iter::map::MapFolder<C,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 1.24%) + + + + + rayon::iter::plumbing::Folder::consume_iter (5 samples, 1.24%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (5 samples, 1.24%) + + + + + core::option::Option<T>::map (5 samples, 1.24%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (5 samples, 1.24%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &F>::call_mut (5 samples, 1.24%) + + + + + evtx::evtx_parser::EvtxParser<T>::serialized_records::{{closure}}::{{closure}} (5 samples, 1.24%) + + + + + core::iter::traits::iterator::Iterator::collect (5 samples, 1.24%) + + + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (5 samples, 1.24%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (5 samples, 1.24%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (5 samples, 1.24%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (4 samples, 1.00%) + + + + + alloc::vec::Vec<T,A>::extend_desugared (4 samples, 1.00%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (4 samples, 1.00%) + + + + + <evtx::evtx_chunk::IterChunkRecords as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + <evtx::binxml::deserializer::IterTokens as core::iter::traits::iterator::Iterator>::next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::inner_next (1 samples, 0.25%) + + + + + evtx::binxml::deserializer::IterTokens::visit_token (1 samples, 0.25%) + + + + + evtx::binxml::tokens::read_template (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + __clone3 (250 samples, 62.19%) + + __clone3 + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (10 samples, 2.49%) + + [[.. + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (1 samples, 0.25%) + + + + + [[kernel.kallsyms]] (28 samples, 6.97%) + + [[kernel... + + + [[kernel.kallsyms]] (73 samples, 18.16%) + + [[kernel.kallsyms]] + + + all (402 samples, 100%) + + + + + Microsoft-Windo (368 samples, 91.54%) + + Microsoft-Windo + + + [[kernel.kallsyms]] (118 samples, 29.35%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (118 samples, 29.35%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (118 samples, 29.35%) + + [[kernel.kallsyms]] + + + diff --git a/releases/0.6.71/flamegraph-help.svg b/releases/0.6.71/flamegraph-help.svg new file mode 100644 index 00000000..61e08dc0 --- /dev/null +++ b/releases/0.6.71/flamegraph-help.svg @@ -0,0 +1,1007 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 9999; created 20240416T000310-0700
; s4 --help + + Reset Zoom + Search + + + + call_init_paths (1 samples, 4.76%) + + call_i.. + + + _dl_init_paths (1 samples, 4.76%) + + _dl_in.. + + + _dl_important_hwcaps (1 samples, 4.76%) + + _dl_im.. + + + update_hwcaps_counts (1 samples, 4.76%) + + update.. + + + _dl_hwcaps_split_masked (1 samples, 4.76%) + + _dl_hw.. + + + _dl_hwcaps_split (1 samples, 4.76%) + + _dl_hw.. + + + _dl_hwcaps_split (1 samples, 4.76%) + + _dl_hw.. + + + elf_machine_rela_relative (1 samples, 4.76%) + + elf_ma.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + elf_machine_rela (1 samples, 4.76%) + + elf_ma.. + + + _dl_lookup_symbol_x (1 samples, 4.76%) + + _dl_lo.. + + + do_lookup_x (1 samples, 4.76%) + + do_loo.. + + + _dl_start (5 samples, 23.81%) + + _dl_start + + + _dl_start_final (5 samples, 23.81%) + + _dl_start_final + + + _dl_sysdep_start (5 samples, 23.81%) + + _dl_sysdep_start + + + dl_main (5 samples, 23.81%) + + dl_main + + + _dl_relocate_object (4 samples, 19.05%) + + _dl_relocate_object + + + elf_dynamic_do_Rela (4 samples, 19.05%) + + elf_dynamic_do_Rela + + + std::rt::init (1 samples, 4.76%) + + std::r.. + + + std::sys::unix::thread::guard::init (1 samples, 4.76%) + + std::s.. + + + std::sys::unix::thread::guard::get_stack_start_aligned (1 samples, 4.76%) + + std::s.. + + + std::sys::unix::thread::guard::get_stack_start (1 samples, 4.76%) + + std::s.. + + + __pthread_getattr_np (1 samples, 4.76%) + + __pthr.. + + + __GI___getdelim (1 samples, 4.76%) + + __GI__.. + + + _IO_new_file_underflow (1 samples, 4.76%) + + _IO_ne.. + + + _start (7 samples, 33.33%) + + _start + + + __libc_start_main_impl (2 samples, 9.52%) + + __libc_start_m.. + + + __libc_start_call_main (2 samples, 9.52%) + + __libc_start_c.. + + + main (2 samples, 9.52%) + + main + + + std::rt::lang_start_internal (2 samples, 9.52%) + + std::rt::lang_.. + + + std::panic::catch_unwind (2 samples, 9.52%) + + std::panic::ca.. + + + std::panicking::try (2 samples, 9.52%) + + std::panicking.. + + + std::panicking::try::do_call (2 samples, 9.52%) + + std::panicking.. + + + std::rt::lang_start_internal::{{closure}} (2 samples, 9.52%) + + std::rt::lang_.. + + + std::panic::catch_unwind (1 samples, 4.76%) + + std::p.. + + + std::panicking::try (1 samples, 4.76%) + + std::p.. + + + std::panicking::try::do_call (1 samples, 4.76%) + + std::p.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (1 samples, 4.76%) + + core::.. + + + std::rt::lang_start::{{closure}} (1 samples, 4.76%) + + std::r.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (1 samples, 4.76%) + + std::s.. + + + core::ops::function::FnOnce::call_once (1 samples, 4.76%) + + core::.. + + + s4::main (1 samples, 4.76%) + + s4::ma.. + + + s4::cli_process_args (1 samples, 4.76%) + + s4::cl.. + + + clap_builder::derive::Parser::parse (1 samples, 4.76%) + + clap_b.. + + + clap_builder::builder::command::Command::get_matches (1 samples, 4.76%) + + clap_b.. + + + clap_builder::builder::command::Command::get_matches_from (1 samples, 4.76%) + + clap_b.. + + + core::result::Result<T,E>::unwrap_or_else (1 samples, 4.76%) + + core::.. + + + clap_builder::builder::command::Command::get_matches_from::{{closure}} (1 samples, 4.76%) + + clap_b.. + + + clap_builder::error::Error<F>::exit (1 samples, 4.76%) + + clap_b.. + + + clap_builder::error::Error<F>::print (1 samples, 4.76%) + + clap_b.. + + + clap_builder::output::fmt::Colorizer::print (1 samples, 4.76%) + + clap_b.. + + + clap_builder::builder::styled_str::StyledStr::write_to (1 samples, 4.76%) + + clap_b.. + + + anstream::strip::write_all (1 samples, 4.76%) + + anstre.. + + + <anstream::adapter::strip::StripBytesIter as core::iter::traits::iterator::Iterator>::next (1 samples, 4.76%) + + <anstr.. + + + anstream::adapter::strip::next_bytes (1 samples, 4.76%) + + anstre.. + + + core::iter::traits::iterator::Iterator::position (1 samples, 4.76%) + + core::.. + + + <core::iter::adapters::copied::Copied<I> as core::iter::traits::iterator::Iterator>::try_fold (1 samples, 4.76%) + + <core:.. + + + core::iter::traits::iterator::Iterator::try_fold (1 samples, 4.76%) + + core::.. + + + core::iter::adapters::copied::copy_try_fold::{{closure}} (1 samples, 4.76%) + + core::.. + + + core::iter::traits::iterator::Iterator::position::check::{{closure}} (1 samples, 4.76%) + + core::.. + + + anstream::adapter::strip::next_bytes::{{closure}} (1 samples, 4.76%) + + anstre.. + + + anstyle_parse::state::state_change (1 samples, 4.76%) + + anstyl.. + + + [unknown] (1 samples, 4.76%) + + [unkno.. + + + s4::cli_process_args (1 samples, 4.76%) + + s4::cl.. + + + clap_builder::derive::Parser::parse (1 samples, 4.76%) + + clap_b.. + + + <s4::CLI_Args as clap_builder::derive::CommandFactory>::command (1 samples, 4.76%) + + <s4::C.. + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 4.76%) + + <s4::C.. + + + clap_builder::builder::arg::Arg::action (1 samples, 4.76%) + + clap_b.. + + + __memmove_avx512_unaligned_erms (1 samples, 4.76%) + + __memm.. + + + [[kernel.kallsyms]] (1 samples, 4.76%) + + [[kern.. + + + s4 (10 samples, 47.62%) + + s4 + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (2 samples, 9.52%) + + [[kernel.kalls.. + + + [[kernel.kallsyms]] (10 samples, 47.62%) + + [[kernel.kallsyms]] + + + all (21 samples, 100%) + + + + + perf-exec (11 samples, 52.38%) + + perf-exec + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 52.38%) + + [[kernel.kallsyms]] + + + diff --git a/releases/0.6.71/flamegraph-journal.svg b/releases/0.6.71/flamegraph-journal.svg new file mode 100644 index 00000000..dbe1241a --- /dev/null +++ b/releases/0.6.71/flamegraph-journal.svg @@ -0,0 +1,1897 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 5000; created 20240415T235704-0700
; s4 ./logs/programs/journal/Ubuntu22-user-1000x3.journal + + Reset Zoom + Search + + + + _dl_relocate_object (1 samples, 3.57%) + + _dl_.. + + + elf_dynamic_do_Rela (1 samples, 3.57%) + + elf_.. + + + elf_machine_rela_relative (1 samples, 3.57%) + + elf_.. + + + _dl_start (2 samples, 7.14%) + + _dl_start + + + _dl_start_final (2 samples, 7.14%) + + _dl_start_.. + + + _dl_sysdep_start (2 samples, 7.14%) + + _dl_sysdep.. + + + dl_main (2 samples, 7.14%) + + dl_main + + + _dl_map_object_deps (1 samples, 3.57%) + + _dl_.. + + + _dl_catch_exception (1 samples, 3.57%) + + _dl_.. + + + openaux (1 samples, 3.57%) + + open.. + + + _dl_map_object (1 samples, 3.57%) + + _dl_.. + + + _dl_map_object_from_fd (1 samples, 3.57%) + + _dl_.. + + + _dl_map_segments (1 samples, 3.57%) + + _dl_.. + + + __mmap64 (1 samples, 3.57%) + + __mm.. + + + __mmap64 (1 samples, 3.57%) + + __mm.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + _dl_relocate_object (1 samples, 3.57%) + + _dl_.. + + + elf_dynamic_do_Rela (1 samples, 3.57%) + + elf_.. + + + elf_machine_rela (1 samples, 3.57%) + + elf_.. + + + _dl_lookup_symbol_x (1 samples, 3.57%) + + _dl_.. + + + dl_new_hash (1 samples, 3.57%) + + dl_n.. + + + _start (4 samples, 14.29%) + + _start + + + __libc_start_main_impl (2 samples, 7.14%) + + __libc_sta.. + + + __libc_start_call_main (2 samples, 7.14%) + + __libc_sta.. + + + main (2 samples, 7.14%) + + main + + + std::rt::lang_start_internal (2 samples, 7.14%) + + std::rt::l.. + + + std::panic::catch_unwind (2 samples, 7.14%) + + std::panic.. + + + std::panicking::try (2 samples, 7.14%) + + std::panic.. + + + std::panicking::try::do_call (2 samples, 7.14%) + + std::panic.. + + + std::rt::lang_start_internal::{{closure}} (2 samples, 7.14%) + + std::rt::l.. + + + std::panic::catch_unwind (2 samples, 7.14%) + + std::panic.. + + + std::panicking::try (2 samples, 7.14%) + + std::panic.. + + + std::panicking::try::do_call (2 samples, 7.14%) + + std::panic.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (2 samples, 7.14%) + + core::ops:.. + + + std::rt::lang_start::{{closure}} (2 samples, 7.14%) + + std::rt::l.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (2 samples, 7.14%) + + std::sys_c.. + + + core::ops::function::FnOnce::call_once (2 samples, 7.14%) + + core::ops:.. + + + s4::main (2 samples, 7.14%) + + s4::main + + + s4::processing_loop (2 samples, 7.14%) + + s4::proces.. + + + s4lib::libload::systemd_dlopen2::load_library_systemd (2 samples, 7.14%) + + s4lib::lib.. + + + dlopen2::wrapper::container::Container<T>::load (2 samples, 7.14%) + + dlopen2::w.. + + + dlopen2::raw::common::Library::open (2 samples, 7.14%) + + dlopen2::r.. + + + dlopen2::raw::unix::open_lib (2 samples, 7.14%) + + dlopen2::r.. + + + ___dlopen (2 samples, 7.14%) + + ___dlopen + + + dlopen_implementation (2 samples, 7.14%) + + dlopen_imp.. + + + _dlerror_run (2 samples, 7.14%) + + _dlerror_r.. + + + __GI__dl_catch_error (2 samples, 7.14%) + + __GI__dl_c.. + + + __GI__dl_catch_exception (2 samples, 7.14%) + + __GI__dl_c.. + + + dlopen_doit (2 samples, 7.14%) + + dlopen_doit + + + _dl_open (2 samples, 7.14%) + + _dl_open + + + __GI__dl_catch_exception (2 samples, 7.14%) + + __GI__dl_c.. + + + dl_open_worker (2 samples, 7.14%) + + dl_open_wo.. + + + __GI__dl_catch_exception (2 samples, 7.14%) + + __GI__dl_c.. + + + dl_open_worker_begin (2 samples, 7.14%) + + dl_open_wo.. + + + _dl_map_object (1 samples, 3.57%) + + _dl_.. + + + _dl_map_object_from_fd (1 samples, 3.57%) + + _dl_.. + + + _dl_map_segments (1 samples, 3.57%) + + _dl_.. + + + __mmap64 (1 samples, 3.57%) + + __mm.. + + + __mmap64 (1 samples, 3.57%) + + __mm.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + __clone3 (1 samples, 3.57%) + + __cl.. + + + start_thread (1 samples, 3.57%) + + star.. + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 3.57%) + + std:.. + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 3.57%) + + <all.. + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 3.57%) + + <all.. + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1 samples, 3.57%) + + core.. + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1 samples, 3.57%) + + std:.. + + + std::sys::unix::thread::Thread::set_name (1 samples, 3.57%) + + std:.. + + + std::sys::unix::thread::truncate_cstr (1 samples, 3.57%) + + std:.. + + + alloc::slice::<impl [T]>::to_vec (1 samples, 3.57%) + + allo.. + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 3.57%) + + allo.. + + + alloc::slice::hack::to_vec (1 samples, 3.57%) + + allo.. + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 3.57%) + + <T a.. + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 3.57%) + + allo.. + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 3.57%) + + allo.. + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 3.57%) + + allo.. + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 3.57%) + + <all.. + + + alloc::alloc::Global::alloc_impl (1 samples, 3.57%) + + allo.. + + + alloc::alloc::alloc (1 samples, 3.57%) + + allo.. + + + __GI___libc_malloc (1 samples, 3.57%) + + __GI.. + + + tcache_init (1 samples, 3.57%) + + tcac.. + + + tcache_init (1 samples, 3.57%) + + tcac.. + + + arena_get2 (1 samples, 3.57%) + + aren.. + + + arena_get2 (1 samples, 3.57%) + + aren.. + + + _int_new_arena (1 samples, 3.57%) + + _int.. + + + new_heap (1 samples, 3.57%) + + new_.. + + + alloc_new_heap (1 samples, 3.57%) + + allo.. + + + regex_automata::meta::regex::Builder::build (1 samples, 3.57%) + + rege.. + + + regex_automata::meta::regex::Builder::build_many (1 samples, 3.57%) + + rege.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 3.57%) + + rege.. + + + regex_automata::meta::strategy::new (1 samples, 3.57%) + + rege.. + + + regex_automata::meta::strategy::Core::new (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 3.57%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 3.57%) + + <cor.. + + + core::option::Option<T>::map (1 samples, 3.57%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 3.57%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 3.57%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 3.57%) + + <cor.. + + + core::option::Option<T>::map (1 samples, 3.57%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 3.57%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 3.57%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 3.57%) + + <cor.. + + + core::option::Option<T>::map (1 samples, 3.57%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 3.57%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 3.57%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 3.57%) + + <cor.. + + + core::option::Option<T>::map (1 samples, 3.57%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 3.57%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 3.57%) + + rege.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 3.57%) + + rege.. + + + alloc::vec::from_elem (1 samples, 3.57%) + + allo.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 3.57%) + + <T a.. + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 3.57%) + + allo.. + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (1 samples, 3.57%) + + <all.. + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (1 samples, 3.57%) + + <reg.. + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (1 samples, 3.57%) + + <all.. + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 3.57%) + + allo.. + + + alloc::slice::hack::to_vec (1 samples, 3.57%) + + allo.. + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 3.57%) + + <T a.. + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 3.57%) + + core.. + + + core::intrinsics::copy_nonoverlapping (1 samples, 3.57%) + + core.. + + + __memmove_avx512_unaligned_erms (1 samples, 3.57%) + + __me.. + + + [unknown] (2 samples, 7.14%) + + [unknown] + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 3.57%) + + <s4:.. + + + <once_cell::sync::Lazy<T,F> as core::ops::deref::Deref>::deref (1 samples, 3.57%) + + <onc.. + + + once_cell::sync::Lazy<T,F>::force (1 samples, 3.57%) + + once.. + + + once_cell::sync::OnceCell<T>::get_or_init (1 samples, 3.57%) + + once.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 3.57%) + + once.. + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 3.57%) + + once.. + + + once_cell::imp::initialize_or_wait (1 samples, 3.57%) + + once.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 3.57%) + + core.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 3.57%) + + once.. + + + once_cell::sync::OnceCell<T>::get_or_init::{{closure}} (1 samples, 3.57%) + + once.. + + + once_cell::sync::Lazy<T,F>::force::{{closure}} (1 samples, 3.57%) + + once.. + + + core::ops::function::FnOnce::call_once (1 samples, 3.57%) + + core.. + + + core::ops::function::FnOnce::call_once (1 samples, 3.57%) + + core.. + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args::DEFAULT_VALUE::{{closure}} (1 samples, 3.57%) + + <s4:.. + + + <s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref (1 samples, 3.57%) + + <s4:.. + + + <s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref::__stability (1 samples, 3.57%) + + <s4:.. + + + lazy_static::lazy::Lazy<T>::get (1 samples, 3.57%) + + lazy.. + + + std::sync::once::Once::call_once (1 samples, 3.57%) + + std:.. + + + std::sys_common::once::futex::Once::call (1 samples, 3.57%) + + std:.. + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 3.57%) + + std:.. + + + lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 3.57%) + + lazy.. + + + core::ops::function::FnOnce::call_once (1 samples, 3.57%) + + core.. + + + <s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 3.57%) + + <s4:.. + + + <s4::LOCAL_NOW as core::ops::deref::Deref>::deref (1 samples, 3.57%) + + <s4:.. + + + <s4::LOCAL_NOW as core::ops::deref::Deref>::deref::__stability (1 samples, 3.57%) + + <s4:.. + + + lazy_static::lazy::Lazy<T>::get (1 samples, 3.57%) + + lazy.. + + + std::sync::once::Once::call_once (1 samples, 3.57%) + + std:.. + + + std::sys_common::once::futex::Once::call (1 samples, 3.57%) + + std:.. + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 3.57%) + + std:.. + + + lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 3.57%) + + lazy.. + + + core::ops::function::FnOnce::call_once (1 samples, 3.57%) + + core.. + + + <s4::LOCAL_NOW as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 3.57%) + + <s4:.. + + + <chrono::datetime::DateTime<chrono::offset::local::Local> as core::convert::From<chrono::datetime::DateTime<chrono::offset::utc::Utc>>>::from (1 samples, 3.57%) + + <chr.. + + + chrono::datetime::DateTime<Tz>::with_timezone (1 samples, 3.57%) + + chro.. + + + chrono::offset::TimeZone::from_utc_datetime (1 samples, 3.57%) + + chro.. + + + <chrono::offset::local::Local as chrono::offset::TimeZone>::offset_from_utc_datetime (1 samples, 3.57%) + + <chr.. + + + chrono::offset::local::inner::offset_from_utc_datetime (1 samples, 3.57%) + + chro.. + + + chrono::offset::local::inner::offset (1 samples, 3.57%) + + chro.. + + + std::thread::local::LocalKey<T>::with (1 samples, 3.57%) + + std:.. + + + std::thread::local::LocalKey<T>::try_with (1 samples, 3.57%) + + std:.. + + + chrono::offset::local::inner::offset::{{closure}} (1 samples, 3.57%) + + chro.. + + + core::option::Option<T>::get_or_insert_with (1 samples, 3.57%) + + core.. + + + core::ops::function::FnOnce::call_once (1 samples, 3.57%) + + core.. + + + <chrono::offset::local::inner::Cache as core::default::Default>::default (1 samples, 3.57%) + + <chr.. + + + chrono::offset::local::inner::current_zone (1 samples, 3.57%) + + chro.. + + + chrono::offset::local::tz_info::timezone::TimeZone::local (1 samples, 3.57%) + + chro.. + + + chrono::offset::local::tz_info::timezone::TimeZone::from_posix_tz (1 samples, 3.57%) + + chro.. + + + chrono::offset::local::tz_info::timezone::TimeZone::from_tz_data (1 samples, 3.57%) + + chro.. + + + chrono::offset::local::tz_info::parser::parse (1 samples, 3.57%) + + chro.. + + + core::str::<impl str>::contains (1 samples, 3.57%) + + core.. + + + <char as core::str::pattern::Pattern>::is_contained_in (1 samples, 3.57%) + + <cha.. + + + core::slice::<impl [T]>::contains (1 samples, 3.57%) + + core.. + + + <u8 as core::slice::cmp::SliceContains>::slice_contains (1 samples, 3.57%) + + <u8 .. + + + core::slice::memchr::memchr (1 samples, 3.57%) + + core.. + + + core::slice::memchr::memchr_aligned (1 samples, 3.57%) + + core.. + + + core::slice::memchr::memchr_naive (1 samples, 3.57%) + + core.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (1 samples, 3.57%) + + [[ke.. + + + [[kernel.kallsyms]] (2 samples, 7.14%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (2 samples, 7.14%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (2 samples, 7.14%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (2 samples, 7.14%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (2 samples, 7.14%) + + [[kernel.k.. + + + s4 (18 samples, 64.29%) + + s4 + + + [[kernel.kallsyms]] (11 samples, 39.29%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 39.29%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 39.29%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (11 samples, 39.29%) + + [[kernel.kallsyms]] + + + perf-exec (9 samples, 32.14%) + + perf-exec + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (9 samples, 32.14%) + + [[kernel.kallsyms]] + + + all (28 samples, 100%) + + + + + Ubuntu22-user-1 (1 samples, 3.57%) + + Ubun.. + + + __clone3 (1 samples, 3.57%) + + __cl.. + + + start_thread (1 samples, 3.57%) + + star.. + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 3.57%) + + std:.. + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 3.57%) + + <all.. + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 3.57%) + + <all.. + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1 samples, 3.57%) + + core.. + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1 samples, 3.57%) + + std:.. + + + std::panic::catch_unwind (1 samples, 3.57%) + + std:.. + + + std::panicking::try (1 samples, 3.57%) + + std:.. + + + std::panicking::try::do_call (1 samples, 3.57%) + + std:.. + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (1 samples, 3.57%) + + <cor.. + + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} (1 samples, 3.57%) + + std:.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (1 samples, 3.57%) + + std:.. + + + s4::processing_loop::{{closure}} (1 samples, 3.57%) + + s4::.. + + + s4::exec_fileprocessor_thread (1 samples, 3.57%) + + s4::.. + + + s4::exec_journalprocessor (1 samples, 3.57%) + + s4::.. + + + s4lib::readers::journalreader::JournalReader::next (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::next_dispatch (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::next_short (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::next_common (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::get_source_realtime_timestamp (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::call_sd_journal_get_data (1 samples, 3.57%) + + s4li.. + + + s4lib::readers::journalreader::JournalReader::Error_from_Errno (1 samples, 3.57%) + + s4li.. + + + alloc::fmt::format (1 samples, 3.57%) + + allo.. + + + core::option::Option<T>::map_or_else (1 samples, 3.57%) + + core.. + + + alloc::fmt::format::{{closure}} (1 samples, 3.57%) + + allo.. + + + alloc::fmt::format::format_inner (1 samples, 3.57%) + + allo.. + + + core::fmt::Write::write_fmt (1 samples, 3.57%) + + core.. + + + core::fmt::write (1 samples, 3.57%) + + core.. + + + <str as core::fmt::Debug>::fmt (1 samples, 3.57%) + + <str.. + + + core::char::methods::<impl char>::escape_debug_ext (1 samples, 3.57%) + + core.. + + + core::unicode::printable::is_printable (1 samples, 3.57%) + + core.. + + + diff --git a/releases/0.6.71/flamegraph-syslog-gz.svg b/releases/0.6.71/flamegraph-syslog-gz.svg new file mode 100644 index 00000000..b586833b --- /dev/null +++ b/releases/0.6.71/flamegraph-syslog-gz.svg @@ -0,0 +1,9192 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 5000; created 20240416T000442-0700
; s4 ./logs/other/tests/gen-1000-3-foobar.log.gz + + Reset Zoom + Search + + + + _dl_relocate_object (1 samples, 0.41%) + + + + + elf_dynamic_do_Rela (1 samples, 0.41%) + + + + + elf_machine_rela_relative (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + _dl_start (2 samples, 0.82%) + + + + + _dl_start_final (2 samples, 0.82%) + + + + + _dl_sysdep_start (2 samples, 0.82%) + + + + + dl_main (2 samples, 0.82%) + + + + + _dl_map_object_deps (1 samples, 0.41%) + + + + + _dl_catch_exception (1 samples, 0.41%) + + + + + openaux (1 samples, 0.41%) + + + + + _dl_map_object (1 samples, 0.41%) + + + + + _dl_map_object_from_fd (1 samples, 0.41%) + + + + + _dl_map_segments (1 samples, 0.41%) + + + + + memset (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + <termcolor::WriterInner<W> as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.82%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (2 samples, 0.82%) + + + + + std::sys::unix::fd::FileDesc::write (2 samples, 0.82%) + + + + + __GI___libc_write (2 samples, 0.82%) + + + + + __GI___libc_write (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + std::io::Write::write_all (3 samples, 1.23%) + + + + + <termcolor::StandardStream as std::io::Write>::write (3 samples, 1.23%) + + + + + <termcolor::LossyStandardStream<W> as std::io::Write>::write (3 samples, 1.23%) + + + + + termcolor::Ansi<W>::write_str (1 samples, 0.41%) + + + + + std::io::Write::write_all (1 samples, 0.41%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (1 samples, 0.41%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (1 samples, 0.41%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.41%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.41%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (1 samples, 0.41%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (1 samples, 0.41%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (1 samples, 0.41%) + + + + + std::sys_common::memchr::memrchr (1 samples, 0.41%) + + + + + std::sys::unix::memchr::memrchr (1 samples, 0.41%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (1 samples, 0.41%) + + + + + __memrchr_evex (1 samples, 0.41%) + + + + + termcolor::Ansi<W>::write_color (1 samples, 0.41%) + + + + + std::io::Write::write_all (1 samples, 0.41%) + + + + + core::slice::<impl [T]>::is_empty (1 samples, 0.41%) + + + + + std::io::stdio::Stdout::lock (1 samples, 0.41%) + + + + + std::sys_common::remutex::ReentrantMutex<T>::lock (1 samples, 0.41%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (1 samples, 0.41%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (1 samples, 0.41%) + + + + + std::sys_common::memchr::memrchr (1 samples, 0.41%) + + + + + std::sys::unix::memchr::memrchr (1 samples, 0.41%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (1 samples, 0.41%) + + + + + __memrchr_evex (1 samples, 0.41%) + + + + + <termcolor::StandardStream as termcolor::WriteColor>::set_color (6 samples, 2.47%) + + <t.. + + + <termcolor::LossyStandardStream<W> as termcolor::WriteColor>::set_color (6 samples, 2.47%) + + <t.. + + + <termcolor::WriterInner<W> as termcolor::WriteColor>::set_color (6 samples, 2.47%) + + <t.. + + + <termcolor::Ansi<W> as termcolor::WriteColor>::set_color (6 samples, 2.47%) + + <t.. + + + <termcolor::Ansi<W> as termcolor::WriteColor>::reset (3 samples, 1.23%) + + + + + termcolor::Ansi<W>::write_str (3 samples, 1.23%) + + + + + std::io::Write::write_all (3 samples, 1.23%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (3 samples, 1.23%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (3 samples, 1.23%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (3 samples, 1.23%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (3 samples, 1.23%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + s4lib::printer::printers::PrinterLogMessage::print_sysline (11 samples, 4.53%) + + s4lib.. + + + s4lib::printer::printers::PrinterLogMessage::print_sysline_color (11 samples, 4.53%) + + s4lib.. + + + <termcolor::StandardStream as std::io::Write>::flush (2 samples, 0.82%) + + + + + <std::io::stdio::Stdout as std::io::Write>::flush (2 samples, 0.82%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::flush (2 samples, 0.82%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::flush (2 samples, 0.82%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::flush (2 samples, 0.82%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::flush (2 samples, 0.82%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (2 samples, 0.82%) + + + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (2 samples, 0.82%) + + + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (2 samples, 0.82%) + + + + + std::sys::unix::fd::FileDesc::write (2 samples, 0.82%) + + + + + __GI___libc_write (2 samples, 0.82%) + + + + + __GI___libc_write (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + core::hint::spin_loop (12 samples, 4.94%) + + core::.. + + + core::core_arch::x86::sse2::_mm_pause (12 samples, 4.94%) + + core::.. + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + crossbeam_utils::backoff::Backoff::snooze (17 samples, 7.00%) + + crossbeam.. + + + __GI___sched_yield (5 samples, 2.06%) + + _.. + + + crossbeam_channel::context::Context::wait_until (18 samples, 7.41%) + + crossbeam_.. + + + <crossbeam_channel::select::Selected as core::convert::From<usize>>::from (1 samples, 0.41%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::unregister (1 samples, 0.41%) + + + + + crossbeam_channel::context::Context::with (20 samples, 8.23%) + + crossbeam_c.. + + + std::thread::local::LocalKey<T>::try_with (20 samples, 8.23%) + + std::thread.. + + + crossbeam_channel::context::Context::with::{{closure}} (20 samples, 8.23%) + + crossbeam_c.. + + + crossbeam_channel::context::Context::with::{{closure}} (20 samples, 8.23%) + + crossbeam_c.. + + + crossbeam_channel::select::run_select::{{closure}} (20 samples, 8.23%) + + crossbeam_c.. + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (1 samples, 0.41%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (1 samples, 0.41%) + + + + + crossbeam_channel::waker::SyncWaker::register (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<std::sync::mutex::MutexGuard<crossbeam_channel::waker::Waker>> (1 samples, 0.41%) + + + + + <std::sync::mutex::MutexGuard<T> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::unlock (1 samples, 0.41%) + + + + + std::rt::lang_start_internal::{{closure}} (32 samples, 13.17%) + + std::rt::lang_start_.. + + + std::panic::catch_unwind (32 samples, 13.17%) + + std::panic::catch_un.. + + + std::panicking::try (32 samples, 13.17%) + + std::panicking::try + + + std::panicking::try::do_call (32 samples, 13.17%) + + std::panicking::try:.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (32 samples, 13.17%) + + core::ops::function:.. + + + std::rt::lang_start::{{closure}} (32 samples, 13.17%) + + std::rt::lang_start:.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (32 samples, 13.17%) + + std::sys_common::bac.. + + + core::ops::function::FnOnce::call_once (32 samples, 13.17%) + + core::ops::function:.. + + + s4::main (32 samples, 13.17%) + + s4::main + + + s4::processing_loop (32 samples, 13.17%) + + s4::processing_loop + + + s4::processing_loop::recv_many_chan (21 samples, 8.64%) + + s4::processi.. + + + crossbeam_channel::select::Select::select (21 samples, 8.64%) + + crossbeam_ch.. + + + crossbeam_channel::select::select (21 samples, 8.64%) + + crossbeam_ch.. + + + crossbeam_channel::select::run_select (21 samples, 8.64%) + + crossbeam_ch.. + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.41%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.41%) + + + + + crossbeam_channel::flavors::array::Channel<T>::start_recv (1 samples, 0.41%) + + + + + _start (35 samples, 14.40%) + + _start + + + __libc_start_main_impl (33 samples, 13.58%) + + __libc_start_main_impl + + + __libc_start_call_main (33 samples, 13.58%) + + __libc_start_call_main + + + main (33 samples, 13.58%) + + main + + + std::rt::lang_start_internal (33 samples, 13.58%) + + std::rt::lang_start_i.. + + + std::panic::catch_unwind (33 samples, 13.58%) + + std::panic::catch_unw.. + + + std::panicking::try (33 samples, 13.58%) + + std::panicking::try + + + std::panicking::try::do_call (33 samples, 13.58%) + + std::panicking::try::.. + + + core::ops::function::FnOnce::call_once (1 samples, 0.41%) + + + + + std::rt::cleanup (1 samples, 0.41%) + + + + + std::sync::once::Once::call_once (1 samples, 0.41%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 0.41%) + + + + + std::sync::once::Once::call_once::{{closure}} (1 samples, 0.41%) + + + + + std::rt::cleanup::{{closure}} (1 samples, 0.41%) + + + + + std::sys::unix::cleanup (1 samples, 0.41%) + + + + + std::sys::unix::stack_overflow::imp::cleanup (1 samples, 0.41%) + + + + + std::sys::unix::stack_overflow::imp::drop_handler (1 samples, 0.41%) + + + + + std::sys::unix::os::page_size (1 samples, 0.41%) + + + + + __GI___sysconf (1 samples, 0.41%) + + + + + linux_sysconf (1 samples, 0.41%) + + + + + posix_sysconf (1 samples, 0.41%) + + + + + __GI___getpagesize (1 samples, 0.41%) + + + + + start_thread (1 samples, 0.41%) + + + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 0.41%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.41%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.41%) + + + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1 samples, 0.41%) + + + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1 samples, 0.41%) + + + + + std::sys::unix::thread::Thread::set_name (1 samples, 0.41%) + + + + + std::sys::unix::thread::truncate_cstr (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + tcache_init (1 samples, 0.41%) + + + + + tcache_init (1 samples, 0.41%) + + + + + arena_get2 (1 samples, 0.41%) + + + + + arena_get2 (1 samples, 0.41%) + + + + + _int_new_arena (1 samples, 0.41%) + + + + + new_heap (1 samples, 0.41%) + + + + + alloc_new_heap (1 samples, 0.41%) + + + + + __GI___munmap (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + __clone3 (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + s4::cli_process_args (1 samples, 0.41%) + + + + + clap_builder::derive::Parser::parse (1 samples, 0.41%) + + + + + <s4::CLI_Args as clap_builder::derive::CommandFactory>::command (1 samples, 0.41%) + + + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 0.41%) + + + + + clap_builder::builder::arg::Arg::help (1 samples, 0.41%) + + + + + <I as clap_builder::builder::resettable::IntoResettable<clap_builder::builder::styled_str::StyledStr>>::into_resettable (1 samples, 0.41%) + + + + + <T as core::convert::Into<U>>::into (1 samples, 0.41%) + + + + + <clap_builder::builder::styled_str::StyledStr as core::convert::From<&str>>::from (1 samples, 0.41%) + + + + + clap_builder::builder::styled_str::StyledStr::none (1 samples, 0.41%) + + + + + <T as core::convert::Into<U>>::into (1 samples, 0.41%) + + + + + <alloc::string::String as core::convert::From<&str>>::from (1 samples, 0.41%) + + + + + alloc::str::<impl alloc::borrow::ToOwned for str>::to_owned (1 samples, 0.41%) + + + + + alloc::slice::<impl alloc::borrow::ToOwned for [T]>::to_owned (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.41%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.41%) + + + + + alloc::vec::from_elem (1 samples, 0.41%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [unknown] (3 samples, 1.23%) + + + + + __GI___sched_yield (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (6 samples, 2.47%) + + [[.. + + + [[kernel.kallsyms]] (6 samples, 2.47%) + + [[.. + + + [[kernel.kallsyms]] (8 samples, 3.29%) + + [[k.. + + + [[kernel.kallsyms]] (8 samples, 3.29%) + + [[k.. + + + [[kernel.kallsyms]] (8 samples, 3.29%) + + [[k.. + + + [[kernel.kallsyms]] (8 samples, 3.29%) + + [[k.. + + + [[kernel.kallsyms]] (8 samples, 3.29%) + + [[k.. + + + s4 (57 samples, 23.46%) + + s4 + + + [[kernel.kallsyms]] (17 samples, 7.00%) + + [[kernel... + + + [[kernel.kallsyms]] (17 samples, 7.00%) + + [[kernel... + + + [[kernel.kallsyms]] (17 samples, 7.00%) + + [[kernel... + + + [[kernel.kallsyms]] (17 samples, 7.00%) + + [[kernel... + + + [[kernel.kallsyms]] (17 samples, 7.00%) + + [[kernel... + + + perf-exec (9 samples, 3.70%) + + perf.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.70%) + + [[ke.. + + + regex_automata::meta::wrappers::PikeVM::create_cache (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::PikeVMCache::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::pikevm::PikeVM::create_cache (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::pikevm::Cache::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::reset (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::pikevm::SlotTable::reset (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::resize (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex_automata::util::pool::Pool<T,F>::get (2 samples, 0.82%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::get (2 samples, 0.82%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::get_slow (2 samples, 0.82%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir::{{closure}} (2 samples, 0.82%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::create_cache (2 samples, 0.82%) + + + + + regex_automata::meta::wrappers::Hybrid::create_cache (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::HybridCache::new (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::HybridCache::new::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::hybrid::regex::Regex::create_cache (1 samples, 0.41%) + + + + + regex_automata::hybrid::regex::Cache::new (1 samples, 0.41%) + + + + + regex_automata::hybrid::dfa::Cache::new (1 samples, 0.41%) + + + + + regex_automata::hybrid::dfa::Lazy::init_cache (1 samples, 0.41%) + + + + + regex_automata::hybrid::dfa::Lazy::set_all_transitions (1 samples, 0.41%) + + + + + <regex_automata::util::alphabet::ByteClassRepresentatives as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::captures (3 samples, 1.23%) + + + + + regex::regex::bytes::Regex::captures_at (3 samples, 1.23%) + + + + + regex_automata::meta::regex::Regex::captures (3 samples, 1.23%) + + + + + regex_automata::meta::regex::Regex::search_captures (3 samples, 1.23%) + + + + + regex_automata::meta::regex::Regex::search_slots (3 samples, 1.23%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::Core::search_slots_nofail (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::OnePassEngine::search_slots (1 samples, 0.41%) + + + + + regex_automata::dfa::onepass::DFA::try_search_slots_imp (1 samples, 0.41%) + + + + + regex_automata::dfa::onepass::DFA::search_imp (1 samples, 0.41%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.41%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.41%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex::builders::bytes::RegexBuilder::new (2 samples, 0.82%) + + + + + regex::builders::Builder::new (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (2 samples, 0.82%) + + + + + core::iter::traits::iterator::Iterator::for_each (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (2 samples, 0.82%) + + + + + <core::array::iter::IntoIter<T,_> as core::iter::traits::iterator::Iterator>::fold (2 samples, 0.82%) + + + + + <core::iter::adapters::by_ref_sized::ByRefSized<I> as core::iter::traits::iterator::Iterator>::fold (2 samples, 0.82%) + + + + + core::iter::traits::iterator::Iterator::try_fold (2 samples, 0.82%) + + + + + <core::const_closure::ConstFnMutClosure<&mut A,Function> as core::ops::function::FnMut<ClosureArguments>>::call_mut (2 samples, 0.82%) + + + + + core::ops::function::Fn::call (2 samples, 0.82%) + + + + + core::ops::try_trait::NeverShortCircuit<T>::wrap_mut_2_imp (2 samples, 0.82%) + + + + + <core::array::iter::IntoIter<T,_> as core::iter::traits::iterator::Iterator>::fold::{{closure}} (2 samples, 0.82%) + + + + + core::iter::adapters::map::map_fold::{{closure}} (2 samples, 0.82%) + + + + + regex::builders::Builder::new::{{closure}} (2 samples, 0.82%) + + + + + <str as alloc::string::ToString>::to_string (2 samples, 0.82%) + + + + + <alloc::string::String as core::convert::From<&str>>::from (2 samples, 0.82%) + + + + + alloc::str::<impl alloc::borrow::ToOwned for str>::to_owned (2 samples, 0.82%) + + + + + alloc::slice::<impl alloc::borrow::ToOwned for [T]>::to_owned (2 samples, 0.82%) + + + + + alloc::slice::<impl [T]>::to_vec (2 samples, 0.82%) + + + + + alloc::slice::<impl [T]>::to_vec_in (2 samples, 0.82%) + + + + + alloc::slice::hack::to_vec (2 samples, 0.82%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + malloc_consolidate (1 samples, 0.41%) + + + + + unlink_chunk (1 samples, 0.41%) + + + + + regex_syntax::hir::ClassUnicode::push (1 samples, 0.41%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::push (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex_syntax::ast::visitor::HeapVisitor::induct (2 samples, 0.82%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class (2 samples, 0.82%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class_post (2 samples, 0.82%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_class_set_item_post (2 samples, 0.82%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_pre (2 samples, 0.82%) + + + + + regex_syntax::hir::translate::TranslatorI::push_char (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.41%) + + + + + core::ptr::mut_ptr::<impl *mut T>::add (1 samples, 0.41%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.41%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.41%) + + + + + regex_syntax::hir::Hir::literal (1 samples, 0.41%) + + + + + regex_syntax::hir::Properties::literal (1 samples, 0.41%) + + + + + core::str::converts::from_utf8 (1 samples, 0.41%) + + + + + core::str::validations::run_utf8_validation (1 samples, 0.41%) + + + + + regex_syntax::hir::translate::TranslatorI::pop_concat_expr (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::translate::HirFrame> (1 samples, 0.41%) + + + + + regex_syntax::hir::translate::TranslatorI::hir_capture (1 samples, 0.41%) + + + + + regex_syntax::hir::Hir::capture (1 samples, 0.41%) + + + + + regex_syntax::hir::Properties::capture (1 samples, 0.41%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.41%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + regex_syntax::hir::ClassUnicode::try_case_fold_simple (1 samples, 0.41%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::case_fold_simple (1 samples, 0.41%) + + + + + <regex_syntax::hir::ClassUnicodeRange as regex_syntax::hir::interval::Interval>::case_fold_simple (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::canonicalize (1 samples, 0.41%) + + + + + regex_syntax::hir::ClassUnicode::new (2 samples, 0.82%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::new (2 samples, 0.82%) + + + + + regex_syntax::hir::translate::TranslatorI::case_fold_char (4 samples, 1.65%) + + + + + regex_syntax::hir::Hir::into_parts (1 samples, 0.41%) + + + + + core::mem::replace (1 samples, 0.41%) + + + + + core::ptr::read (1 samples, 0.41%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<regex_syntax::hir::Hir>> (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + regex_syntax::hir::Hir::concat (3 samples, 1.23%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + tcache_put (1 samples, 0.41%) + + + + + regex_syntax::hir::Hir::class (1 samples, 0.41%) + + + + + regex_syntax::hir::Class::literal (1 samples, 0.41%) + + + + + regex_syntax::hir::ClassUnicode::literal (1 samples, 0.41%) + + + + + <T as alloc::string::ToString>::to_string (1 samples, 0.41%) + + + + + <&mut T as core::fmt::Display>::fmt (1 samples, 0.41%) + + + + + <alloc::string::String as core::fmt::Write>::write_str (1 samples, 0.41%) + + + + + alloc::string::String::push_str (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + core::result::Result<T,E>::map_err (1 samples, 0.41%) + + + + + core::mem::replace (1 samples, 0.41%) + + + + + core::ptr::read (1 samples, 0.41%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init (1 samples, 0.41%) + + + + + regex_syntax::hir::Hir::alternation (2 samples, 0.82%) + + + + + regex_syntax::hir::Hir::into_parts (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_post (21 samples, 8.64%) + + <regex_synta.. + + + regex_syntax::hir::translate::Translator::translate (26 samples, 10.70%) + + regex_syntax::hi.. + + + regex_syntax::ast::visitor::visit (26 samples, 10.70%) + + regex_syntax::as.. + + + regex_syntax::ast::visitor::HeapVisitor::visit (26 samples, 10.70%) + + regex_syntax::as.. + + + regex_syntax::ast::visitor::HeapVisitor::induct (1 samples, 0.41%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class (1 samples, 0.41%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class_pre (1 samples, 0.41%) + + + + + <core::result::Result<T,E> as core::ops::try_trait::Try>::branch (1 samples, 0.41%) + + + + + regex_syntax::ast::visitor::visit (2 samples, 0.82%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit (2 samples, 0.82%) + + + + + <regex_syntax::ast::parse::NestLimiter<P> as regex_syntax::ast::visitor::Visitor>::visit_pre (1 samples, 0.41%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::Primitive::into_ast (2 samples, 0.82%) + + + + + regex_syntax::ast::Ast::literal (2 samples, 0.82%) + + + + + alloc::boxed::Box<T>::new (2 samples, 0.82%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_group (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_group (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_capture_name (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_or_add_alternation (1 samples, 0.41%) + + + + + regex_syntax::ast::Concat::into_ast (1 samples, 0.41%) + + + + + regex_syntax::ast::Ast::concat (1 samples, 0.41%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_alternate (3 samples, 1.23%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_class_open (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_class (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_class_op (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex_syntax::ast::ClassSetUnion::push (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_set_class (4 samples, 1.65%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_primitive (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::bump (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_counted_repetition (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::specialize_err (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex_syntax::ast::parse::Parser::parse (17 samples, 7.00%) + + regex_syn.. + + + regex_syntax::ast::parse::ParserI<P>::parse (17 samples, 7.00%) + + regex_syn.. + + + regex_syntax::ast::parse::ParserI<P>::parse_with_comments (17 samples, 7.00%) + + regex_syn.. + + + <core::result::Result<T,E> as core::ops::try_trait::Try>::branch (2 samples, 0.82%) + + + + + regex_syntax::hir::Hir::empty (1 samples, 0.41%) + + + + + regex_syntax::hir::Properties::empty (1 samples, 0.41%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.41%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + tcache_get (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::hir::Hir>> (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<[regex_syntax::hir::Hir]> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (2 samples, 0.82%) + + + + + <regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + malloc_consolidate (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::Repetition>> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Repetition> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::Ast>> (1 samples, 0.41%) + + + + + alloc::alloc::box_free (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (3 samples, 1.23%) + + + + + __memmove_avx512_unaligned_erms (2 samples, 0.82%) + + + + + unlink_chunk (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::ClassBracketed>> (5 samples, 2.06%) + + c.. + + + core::ptr::drop_in_place<regex_syntax::ast::ClassBracketed> (5 samples, 2.06%) + + c.. + + + core::ptr::drop_in_place<regex_syntax::ast::ClassSet> (5 samples, 2.06%) + + c.. + + + <regex_syntax::ast::ClassSet as core::ops::drop::Drop>::drop (5 samples, 2.06%) + + <.. + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (3 samples, 1.23%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (3 samples, 1.23%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (3 samples, 1.23%) + + + + + alloc::vec::Vec<T,A>::reserve (3 samples, 1.23%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (3 samples, 1.23%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (3 samples, 1.23%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (3 samples, 1.23%) + + + + + alloc::raw_vec::finish_grow (3 samples, 1.23%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (3 samples, 1.23%) + + + + + alloc::alloc::Global::grow_impl (3 samples, 1.23%) + + + + + alloc::alloc::realloc (3 samples, 1.23%) + + + + + __GI___libc_realloc (3 samples, 1.23%) + + + + + _int_realloc (3 samples, 1.23%) + + + + + _int_malloc (3 samples, 1.23%) + + + + + malloc_consolidate (3 samples, 1.23%) + + + + + _int_free (2 samples, 0.82%) + + + + + __GI___libc_free (3 samples, 1.23%) + + + + + regex_automata::meta::regex::Builder::build (57 samples, 23.46%) + + regex_automata::meta::regex::Builder:.. + + + regex_automata::meta::regex::Builder::build_many (57 samples, 23.46%) + + regex_automata::meta::regex::Builder:.. + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::ast::Ast>> (12 samples, 4.94%) + + core::.. + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (12 samples, 4.94%) + + <alloc.. + + + core::ptr::drop_in_place<[regex_syntax::ast::Ast]> (12 samples, 4.94%) + + core::.. + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (12 samples, 4.94%) + + core::.. + + + <regex_syntax::ast::Ast as core::ops::drop::Drop>::drop (12 samples, 4.94%) + + <regex.. + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + malloc_consolidate (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (63 samples, 25.93%) + + s4lib::readers::syslogprocessor::SyslogPr.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (63 samples, 25.93%) + + s4lib::readers::syslinereader::SyslineRea.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (63 samples, 25.93%) + + s4lib::readers::syslinereader::SyslineRea.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (63 samples, 25.93%) + + s4lib::readers::syslinereader::SyslineRea.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (63 samples, 25.93%) + + s4lib::readers::syslinereader::SyslineRea.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (63 samples, 25.93%) + + s4lib::readers::syslinereader::SyslineRea.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (63 samples, 25.93%) + + s4lib::data::datetime::bytes_to_regex_to_.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (60 samples, 24.69%) + + once_cell::sync::OnceCell<T>::get_or_tr.. + + + once_cell::imp::OnceCell<T>::initialize (60 samples, 24.69%) + + once_cell::imp::OnceCell<T>::initialize + + + once_cell::imp::initialize_or_wait (60 samples, 24.69%) + + once_cell::imp::initialize_or_wait + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (60 samples, 24.69%) + + core::ops::function::impls::<impl core:.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (60 samples, 24.69%) + + once_cell::imp::OnceCell<T>::initialize.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (60 samples, 24.69%) + + s4lib::data::datetime::bytes_to_regex_t.. + + + regex::regex::bytes::Regex::new (60 samples, 24.69%) + + regex::regex::bytes::Regex::new + + + regex::builders::bytes::RegexBuilder::build (58 samples, 23.87%) + + regex::builders::bytes::RegexBuilder::.. + + + regex::builders::Builder::build_one_bytes (58 samples, 23.87%) + + regex::builders::Builder::build_one_by.. + + + <alloc::sync::Arc<str> as core::convert::From<&str>>::from (1 samples, 0.41%) + + + + + <alloc::sync::Arc<[T]> as core::convert::From<&[T]>>::from (1 samples, 0.41%) + + + + + <alloc::sync::Arc<[T]> as alloc::sync::ArcFromSlice<T>>::from_slice (1 samples, 0.41%) + + + + + alloc::sync::Arc<[T]>::copy_from_slice (1 samples, 0.41%) + + + + + alloc::sync::Arc<[T]>::allocate_for_slice (1 samples, 0.41%) + + + + + alloc::sync::Arc<T>::allocate_for_layout (1 samples, 0.41%) + + + + + alloc::sync::Arc<T>::try_allocate_for_layout (1 samples, 0.41%) + + + + + alloc::sync::Arc<[T]>::allocate_for_slice::{{closure}} (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (64 samples, 26.34%) + + s4lib::readers::syslogprocessor::SyslogPro.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (64 samples, 26.34%) + + s4lib::readers::syslogprocessor::SyslogPro.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_bytes (1 samples, 0.41%) + + + + + s4lib::readers::blockreader::BlockReader::read_block (1 samples, 0.41%) + + + + + s4lib::readers::blockreader::BlockReader::read_block_FileGz (1 samples, 0.41%) + + + + + alloc::vec::Vec<T>::with_capacity (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + s4lib::data::line::Line::get_boxptrs (1 samples, 0.41%) + + + + + s4lib::data::line::LinePart::block_boxptr_ab (1 samples, 0.41%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.41%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + chrono::offset::TimeZone::from_local_datetime (1 samples, 0.41%) + + + + + chrono::offset::LocalResult<T>::and_then (1 samples, 0.41%) + + + + + chrono::offset::LocalResult::Single (1 samples, 0.41%) + + + + + s4lib::data::datetime::datetime_parse_from_str (5 samples, 2.06%) + + s.. + + + chrono::naive::datetime::NaiveDateTime::parse_from_str (4 samples, 1.65%) + + + + + chrono::format::parse::parse (4 samples, 1.65%) + + + + + chrono::format::parse::parse_internal (4 samples, 1.65%) + + + + + core::hash::impls::<impl core::hash::Hash for &T>::hash (1 samples, 0.41%) + + + + + core::hash::impls::<impl core::hash::Hash for str>::hash (1 samples, 0.41%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write_str (1 samples, 0.41%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::write_str (1 samples, 0.41%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write_str (1 samples, 0.41%) + + + + + core::hash::Hasher::write_u8 (1 samples, 0.41%) + + + + + s4lib::data::datetime::captures_to_buffer_bytes (2 samples, 0.82%) + + + + + regex::regex::bytes::Captures::name (2 samples, 0.82%) + + + + + regex_automata::util::captures::Captures::get_group_by_name (2 samples, 0.82%) + + + + + regex_automata::util::captures::GroupInfo::to_index (2 samples, 0.82%) + + + + + std::collections::hash::map::HashMap<K,V,S>::get (2 samples, 0.82%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get (2 samples, 0.82%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner (2 samples, 0.82%) + + + + + hashbrown::map::make_hash (2 samples, 0.82%) + + + + + core::hash::BuildHasher::hash_one (2 samples, 0.82%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::captures (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::captures_at (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Regex::captures (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Regex::search_captures (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Regex::search_slots (1 samples, 0.41%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::Core::search_slots_nofail (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::BoundedBacktrackerEngine::search_slots (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (10 samples, 4.12%) + + s4li.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (9 samples, 3.70%) + + s4li.. + + + regex::regex::bytes::Captures::name (1 samples, 0.41%) + + + + + regex_automata::util::captures::Captures::get_group_by_name (1 samples, 0.41%) + + + + + regex_automata::util::captures::GroupInfo::to_index (1 samples, 0.41%) + + + + + std::collections::hash::map::HashMap<K,V,S>::get (1 samples, 0.41%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get (1 samples, 0.41%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner (1 samples, 0.41%) + + + + + hashbrown::map::make_hash (1 samples, 0.41%) + + + + + core::hash::BuildHasher::hash_one (1 samples, 0.41%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (1 samples, 0.41%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::d_rounds (1 samples, 0.41%) + + + + + core::num::<impl u64>::rotate_left (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (2 samples, 0.82%) + + + + + itertools::Itertools::sorted_by (3 samples, 1.23%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::iter (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (15 samples, 6.17%) + + s4lib::r.. + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<&T>>::extend (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,I>>::spec_extend (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (16 samples, 6.58%) + + s4lib::re.. + + + lru::LruCache<K,V,S>::put (1 samples, 0.41%) + + + + + lru::LruCache<K,V,S>::capturing_put (1 samples, 0.41%) + + + + + hashbrown::map::HashMap<K,V,S,A>::insert (1 samples, 0.41%) + + + + + hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot (1 samples, 0.41%) + + + + + hashbrown::raw::RawTableInner::find_or_find_insert_slot_inner (1 samples, 0.41%) + + + + + hashbrown::raw::sse2::Group::match_byte (1 samples, 0.41%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.41%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (1 samples, 0.41%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_lower_bound_index (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (1 samples, 0.41%) + + + + + <rangemap::range_wrapper::RangeStartWrapper<T> as core::cmp::Ord>::cmp (1 samples, 0.41%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (1 samples, 0.41%) + + + + + rangemap::map::RangeMap<K,V>::insert (2 samples, 0.82%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (2 samples, 0.82%) + + + + + s4lib::readers::syslinereader::SyslineReader::insert_sysline (3 samples, 1.23%) + + + + + alloc::sync::Arc<T>::new (1 samples, 0.41%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.41%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __rust_alloc (1 samples, 0.41%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (2 samples, 0.82%) + + + + + s4lib::readers::syslinereader::SyslineReader::check_store (3 samples, 1.23%) + + + + + rangemap::map::RangeMap<K,V>::get_key_value (3 samples, 1.23%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (3 samples, 1.23%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (1 samples, 0.41%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_lower_bound_index (1 samples, 0.41%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (1 samples, 0.41%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (1 samples, 0.41%) + + + + + s4lib::readers::linereader::LineReader::check_store (2 samples, 0.82%) + + + + + s4lib::readers::linereader::LineReader::get_linep (2 samples, 0.82%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::resize (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.41%) + + + + + miniz_oxide::inflate::core::transfer (1 samples, 0.41%) + + + + + <flate2::ffi::rust::Inflate as flate2::ffi::InflateBackend>::decompress (2 samples, 0.82%) + + + + + miniz_oxide::inflate::stream::inflate (2 samples, 0.82%) + + + + + miniz_oxide::inflate::stream::inflate_loop (2 samples, 0.82%) + + + + + miniz_oxide::inflate::core::decompress (2 samples, 0.82%) + + + + + miniz_oxide::inflate::core::decompress_fast (2 samples, 0.82%) + + + + + miniz_oxide::inflate::core::fill_bit_buffer (1 samples, 0.41%) + + + + + <flate2::gz::read::GzDecoder<R> as std::io::Read>::read (3 samples, 1.23%) + + + + + <flate2::gz::bufread::GzDecoder<R> as std::io::Read>::read (3 samples, 1.23%) + + + + + <flate2::crc::CrcReader<R> as std::io::Read>::read (3 samples, 1.23%) + + + + + <flate2::deflate::bufread::DeflateDecoder<R> as std::io::Read>::read (3 samples, 1.23%) + + + + + flate2::zio::read (3 samples, 1.23%) + + + + + <flate2::bufreader::BufReader<R> as std::io::BufRead>::consume (1 samples, 0.41%) + + + + + core::cmp::min (1 samples, 0.41%) + + + + + core::cmp::Ord::min (1 samples, 0.41%) + + + + + s4lib::readers::blockreader::BlockReader::read_block (5 samples, 2.06%) + + s.. + + + s4lib::readers::blockreader::BlockReader::read_block_FileGz (5 samples, 2.06%) + + s.. + + + s4lib::data::line::Line::prepend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + __rust_alloc (1 samples, 0.41%) + + + + + s4lib::data::line::Line::new (2 samples, 0.82%) + + + + + <s4lib::data::line::Line as core::default::Default>::default (2 samples, 0.82%) + + + + + alloc::vec::Vec<T>::with_capacity (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (2 samples, 0.82%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (2 samples, 0.82%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (2 samples, 0.82%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (2 samples, 0.82%) + + + + + alloc::alloc::Global::alloc_impl (2 samples, 0.82%) + + + + + alloc::alloc::alloc (2 samples, 0.82%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + lru::LruCache<K,V,S>::put (1 samples, 0.41%) + + + + + lru::LruCache<K,V,S>::capturing_put (1 samples, 0.41%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (1 samples, 0.41%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (1 samples, 0.41%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (1 samples, 0.41%) + + + + + hashbrown::raw::RawTable<T,A>::find (1 samples, 0.41%) + + + + + hashbrown::raw::RawTableInner::find_inner (1 samples, 0.41%) + + + + + hashbrown::raw::h2 (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (2 samples, 0.82%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (2 samples, 0.82%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index (2 samples, 0.82%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::find_sysline_between_datetime_filters (39 samples, 16.05%) + + s4lib::readers::syslogpro.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_between_datetime_filters (39 samples, 16.05%) + + s4lib::readers::syslinere.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_at_datetime_filter_binary_search (39 samples, 16.05%) + + s4lib::readers::syslinere.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline (39 samples, 16.05%) + + s4lib::readers::syslinere.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_year (39 samples, 16.05%) + + s4lib::readers::syslinere.. + + + s4lib::readers::linereader::LineReader::find_line (17 samples, 7.00%) + + s4lib::re.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::drop_data_try (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::drop_data (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_data (1 samples, 0.41%) + + + + + <core::iter::adapters::filter::Filter<I,P> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::iter::traits::iterator::Iterator::find (1 samples, 0.41%) + + + + + core::iter::traits::iterator::Iterator::try_fold (1 samples, 0.41%) + + + + + core::iter::traits::iterator::Iterator::find::check::{{closure}} (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_data::{{closure}} (1 samples, 0.41%) + + + + + __clone3 (105 samples, 43.21%) + + __clone3 + + + start_thread (105 samples, 43.21%) + + start_thread + + + std::sys::unix::thread::Thread::new::thread_start (105 samples, 43.21%) + + std::sys::unix::thread::Thread::new::thread_start + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (105 samples, 43.21%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (105 samples, 43.21%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (105 samples, 43.21%) + + core::ops::function::FnOnce::call_once{{vtable.shim}} + + + std::thread::Builder::spawn_unchecked_::{{closure}} (105 samples, 43.21%) + + std::thread::Builder::spawn_unchecked_::{{closure}} + + + std::panic::catch_unwind (105 samples, 43.21%) + + std::panic::catch_unwind + + + std::panicking::try (105 samples, 43.21%) + + std::panicking::try + + + std::panicking::try::do_call (105 samples, 43.21%) + + std::panicking::try::do_call + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (105 samples, 43.21%) + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::.. + + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} (105 samples, 43.21%) + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} + + + std::sys_common::backtrace::__rust_begin_short_backtrace (105 samples, 43.21%) + + std::sys_common::backtrace::__rust_begin_short_backtrace + + + s4::processing_loop::{{closure}} (105 samples, 43.21%) + + s4::processing_loop::{{closure}} + + + s4::exec_fileprocessor_thread (105 samples, 43.21%) + + s4::exec_fileprocessor_thread + + + s4::exec_syslogprocessor (105 samples, 43.21%) + + s4::exec_syslogprocessor + + + s4::chan_send (1 samples, 0.41%) + + + + + crossbeam_channel::channel::Sender<T>::send (1 samples, 0.41%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send (1 samples, 0.41%) + + + + + crossbeam_channel::flavors::array::Channel<T>::write (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (1 samples, 0.41%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.41%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.41%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.41%) + + + + + regex::builders::bytes::RegexBuilder::build (1 samples, 0.41%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::BoundedBacktracker::new (1 samples, 0.41%) + + + + + regex_automata::meta::wrappers::BoundedBacktrackerEngine::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::backtrack::Builder::configure (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::backtrack::Config::overwrite (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.41%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.41%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.41%) + + + + + regex::builders::bytes::RegexBuilder::build (1 samples, 0.41%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::ReverseInner::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::nfa::Inner::add (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + malloc_consolidate (1 samples, 0.41%) + + + + + regex_automata::util::primitives::<impl core::ops::index::Index<regex_automata::util::primitives::StateID> for [T]>::index (1 samples, 0.41%) + + + + + regex_automata::util::primitives::<impl core::ops::index::Index<regex_automata::util::primitives::StateID> for [T]>::index (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::nfa::Inner::remap (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::nfa::State::remap (2 samples, 0.82%) + + + + + regex_automata::util::primitives::StateID::new (1 samples, 0.41%) + + + + + regex_automata::util::primitives::SmallIndex::new (1 samples, 0.41%) + + + + + <regex_automata::util::primitives::SmallIndex as core::convert::TryFrom<usize>>::try_from (1 samples, 0.41%) + + + + + regex_automata::util::alphabet::ByteClassSet::set_range (2 samples, 0.82%) + + + + + regex_automata::util::alphabet::ByteSet::add (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::nfa::State::memory_usage (1 samples, 0.41%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (8 samples, 3.29%) + + s4l.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (8 samples, 3.29%) + + s4l.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (8 samples, 3.29%) + + s4l.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (8 samples, 3.29%) + + s4l.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (8 samples, 3.29%) + + s4l.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (8 samples, 3.29%) + + onc.. + + + once_cell::imp::OnceCell<T>::initialize (8 samples, 3.29%) + + onc.. + + + once_cell::imp::initialize_or_wait (8 samples, 3.29%) + + onc.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (8 samples, 3.29%) + + cor.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (8 samples, 3.29%) + + onc.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (8 samples, 3.29%) + + s4l.. + + + regex::regex::bytes::Regex::new (8 samples, 3.29%) + + reg.. + + + regex::builders::bytes::RegexBuilder::build (8 samples, 3.29%) + + reg.. + + + regex::builders::Builder::build_one_bytes (8 samples, 3.29%) + + reg.. + + + regex_automata::meta::regex::Builder::build (8 samples, 3.29%) + + reg.. + + + regex_automata::meta::regex::Builder::build_many (8 samples, 3.29%) + + reg.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (8 samples, 3.29%) + + reg.. + + + regex_automata::meta::strategy::new (8 samples, 3.29%) + + reg.. + + + regex_automata::meta::strategy::Core::new (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::builder::Builder::build (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::nfa::Inner::add (5 samples, 2.06%) + + r.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.41%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.41%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.41%) + + + + + regex::builders::bytes::RegexBuilder::build (1 samples, 0.41%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::nfa::Inner::into_nfa (1 samples, 0.41%) + + + + + regex_automata::util::sparse_set::SparseSet::new (1 samples, 0.41%) + + + + + regex_automata::util::sparse_set::SparseSet::resize (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::resize (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::ReverseInner::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_range (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.41%) + + + + + <regex_automata::nfa::thompson::literal_trie::State as core::default::Default>::default (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 1.23%) + + + + + core::option::Option<T>::map (3 samples, 1.23%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.23%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.41%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + core::slice::<impl [T]>::binary_search_by_key (1 samples, 0.41%) + + + + + core::slice::<impl [T]>::binary_search_by (1 samples, 0.41%) + + + + + core::slice::<impl [T]>::binary_search_by_key::{{closure}} (1 samples, 0.41%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u8>::cmp (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (6 samples, 2.47%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile (6 samples, 2.47%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (6 samples, 2.47%) + + re.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (6 samples, 2.47%) + + <c.. + + + core::option::Option<T>::map (6 samples, 2.47%) + + co.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (6 samples, 2.47%) + + co.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (6 samples, 2.47%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (6 samples, 2.47%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (6 samples, 2.47%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (6 samples, 2.47%) + + re.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (3 samples, 1.23%) + + + + + core::option::Option<T>::map (3 samples, 1.23%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.23%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.23%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<(usize,usize)>> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<(usize,usize)>> (1 samples, 0.41%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + regex_automata::dfa::onepass::InternalBuilder::shuffle_states (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + regex_automata::util::primitives::<impl core::ops::index::IndexMut<regex_automata::util::primitives::StateID> for alloc::vec::Vec<T>>::index_mut (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::IndexMut<I>>::index_mut (1 samples, 0.41%) + + + + + core::slice::index::<impl core::ops::index::IndexMut<I> for [T]>::index_mut (1 samples, 0.41%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index_mut (1 samples, 0.41%) + + + + + regex_automata::dfa::onepass::InternalBuilder::add_empty_state (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.41%) + + + + + <core::iter::adapters::take::Take<I> as core::iter::traits::iterator::Iterator>::for_each (1 samples, 0.41%) + + + + + core::iter::traits::iterator::Iterator::try_fold (1 samples, 0.41%) + + + + + <core::iter::adapters::take::Take<I> as core::iter::traits::iterator::Iterator>::for_each::check::{{closure}} (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_trusted::{{closure}} (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (12 samples, 4.94%) + + s4lib:.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (12 samples, 4.94%) + + once_c.. + + + once_cell::imp::OnceCell<T>::initialize (12 samples, 4.94%) + + once_c.. + + + once_cell::imp::initialize_or_wait (12 samples, 4.94%) + + once_c.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (12 samples, 4.94%) + + core::.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (12 samples, 4.94%) + + once_c.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (12 samples, 4.94%) + + s4lib:.. + + + regex::regex::bytes::Regex::new (12 samples, 4.94%) + + regex:.. + + + regex::builders::bytes::RegexBuilder::build (12 samples, 4.94%) + + regex:.. + + + regex::builders::Builder::build_one_bytes (12 samples, 4.94%) + + regex:.. + + + regex_automata::meta::regex::Builder::build (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::regex::Builder::build_many (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::strategy::new (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::strategy::Core::new (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::wrappers::OnePass::new (5 samples, 2.06%) + + r.. + + + regex_automata::meta::wrappers::OnePassEngine::new (5 samples, 2.06%) + + r.. + + + regex_automata::dfa::onepass::Builder::build_from_nfa (5 samples, 2.06%) + + r.. + + + regex_automata::dfa::onepass::InternalBuilder::build (5 samples, 2.06%) + + r.. + + + regex_automata::dfa::onepass::InternalBuilder::compile_transition (4 samples, 1.65%) + + + + + regex_automata::dfa::onepass::InternalBuilder::add_dfa_state_for_nfa_state (4 samples, 1.65%) + + + + + regex_automata::util::prefilter::prefixes (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::retain_mut::process_loop (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::create_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::ReverseSuffix::new (1 samples, 0.41%) + + + + + regex_automata::util::prefilter::suffixes (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::extract_concat (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::extract_concat (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::cross (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::cross_reverse (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::dedup (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::dedup_by (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::dedup::{{closure}} (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Literal::as_bytes (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::literal::PreferenceTrie> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::hir::literal::State>> (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<[regex_syntax::hir::literal::State]> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::literal::State> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<(u8,usize)>> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<(u8,usize)>> (1 samples, 0.41%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (2 samples, 0.82%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (2 samples, 0.82%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::retain_mut::process_loop (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (1 samples, 0.41%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (1 samples, 0.41%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index (1 samples, 0.41%) + + + + + regex_automata::meta::reverse_inner::prefilter (3 samples, 1.23%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::extract_alternation (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Extractor::union (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::union (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::dedup (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::dedup_by (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Seq::dedup::{{closure}} (1 samples, 0.41%) + + + + + regex_syntax::hir::literal::Literal::as_bytes (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::ReverseInner::new (4 samples, 1.65%) + + + + + regex_automata::meta::reverse_inner::extract (4 samples, 1.65%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.41%) + + + + + <regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::hir::Hir>> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Properties> (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::hir::PropertiesI>> (1 samples, 0.41%) + + + + + alloc::alloc::box_free (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::compiler::Utf8State>> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::compiler::Utf8State>> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Utf8State> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::map::Utf8BoundedMap> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::map::Utf8BoundedEntry>> (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::map::Utf8BoundedEntry]> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::map::Utf8BoundedEntry> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::nfa::Transition>> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::nfa::Transition>> (2 samples, 0.82%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.82%) + + + + + alloc::raw_vec::RawVec<T,A>::current_memory (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::builder::State>> (1 samples, 0.41%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.41%) + + + + + alloc::alloc::dealloc (1 samples, 0.41%) + + + + + __GI___libc_free (1 samples, 0.41%) + + + + + _int_free (1 samples, 0.41%) + + + + + malloc_consolidate (1 samples, 0.41%) + + + + + s4::exec_fileprocessor_thread (11 samples, 4.53%) + + s4::e.. + + + s4::exec_syslogprocessor (11 samples, 4.53%) + + s4::e.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (11 samples, 4.53%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (11 samples, 4.53%) + + s4lib.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (11 samples, 4.53%) + + s4lib.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (11 samples, 4.53%) + + once_.. + + + once_cell::imp::OnceCell<T>::initialize (11 samples, 4.53%) + + once_.. + + + once_cell::imp::initialize_or_wait (11 samples, 4.53%) + + once_.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (11 samples, 4.53%) + + core:.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (11 samples, 4.53%) + + once_.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (11 samples, 4.53%) + + s4lib.. + + + regex::regex::bytes::Regex::new (11 samples, 4.53%) + + regex.. + + + regex::builders::bytes::RegexBuilder::build (11 samples, 4.53%) + + regex.. + + + regex::builders::Builder::build_one_bytes (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::regex::Builder::build (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::regex::Builder::build_many (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::strategy::new (11 samples, 4.53%) + + regex.. + + + regex_automata::meta::strategy::Core::new (5 samples, 2.06%) + + r.. + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (5 samples, 2.06%) + + c.. + + + core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::builder::Builder>> (3 samples, 1.23%) + + + + + core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::builder::Builder>> (3 samples, 1.23%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::Builder> (3 samples, 1.23%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::builder::State>> (3 samples, 1.23%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::builder::State]> (2 samples, 0.82%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::State> (2 samples, 0.82%) + + + + + __GI___libc_free (2 samples, 0.82%) + + + + + _int_free (2 samples, 0.82%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::densify (1 samples, 0.41%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (2 samples, 0.82%) + + + + + aho_corasick::dfa::Builder::build (2 samples, 0.82%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (2 samples, 0.82%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::compile (2 samples, 0.82%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::build_trie (1 samples, 0.41%) + + + + + aho_corasick::nfa::noncontiguous::NFA::alloc_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::new (3 samples, 1.23%) + + + + + regex_automata::meta::strategy::ReverseInner::new (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::extract (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::prefilter (3 samples, 1.23%) + + + + + core::option::Option<T>::and_then (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::prefilter::{{closure}} (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::Prefilter::new (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::Choice::new (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::aho_corasick::AhoCorasick::new (1 samples, 0.41%) + + + + + aho_corasick::ahocorasick::AhoCorasickBuilder::build (1 samples, 0.41%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (1 samples, 0.41%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::compile (1 samples, 0.41%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::add_unanchored_start_state_loop (1 samples, 0.41%) + + + + + aho_corasick::packed::api::Builder::extend (1 samples, 0.41%) + + + + + aho_corasick::packed::api::Builder::add (1 samples, 0.41%) + + + + + aho_corasick::packed::pattern::Patterns::add (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.41%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.41%) + + + + + alloc::alloc::alloc (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (2 samples, 0.82%) + + + + + aho_corasick::dfa::Builder::build (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start (1 samples, 0.41%) + + + + + aho_corasick::dfa::sparse_iter (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::meta::strategy::ReverseInner::new (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::extract (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::prefilter (3 samples, 1.23%) + + + + + core::option::Option<T>::and_then (3 samples, 1.23%) + + + + + regex_automata::meta::reverse_inner::prefilter::{{closure}} (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::Prefilter::new (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::Choice::new (3 samples, 1.23%) + + + + + regex_automata::util::prefilter::aho_corasick::AhoCorasick::new (1 samples, 0.41%) + + + + + aho_corasick::ahocorasick::AhoCorasickBuilder::build (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (1 samples, 0.41%) + + + + + aho_corasick::dfa::Builder::finish_build_both_starts (1 samples, 0.41%) + + + + + aho_corasick::dfa::sparse_iter (1 samples, 0.41%) + + + + + core::cmp::PartialEq::ne (1 samples, 0.41%) + + + + + <core::option::Option<T> as core::cmp::PartialEq>::eq (1 samples, 0.41%) + + + + + <T as core::option::SpecOptionPartialEq>::eq (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + core::ptr::write (5 samples, 2.06%) + + c.. + + + [[kernel.kallsyms]] (5 samples, 2.06%) + + [.. + + + core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.41%) + + + + + <core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.41%) + + + + + core::cmp::impls::<impl core::cmp::PartialOrd for usize>::lt (1 samples, 0.41%) + + + + + <regex_automata::util::primitives::StateID as core::clone::Clone>::clone (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (8 samples, 3.29%) + + reg.. + + + alloc::vec::from_elem (8 samples, 3.29%) + + all.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (8 samples, 3.29%) + + <T .. + + + alloc::vec::Vec<T,A>::extend_with (8 samples, 3.29%) + + all.. + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (2 samples, 0.82%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.41%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.41%) + + + + + alloc::vec::from_elem (1 samples, 0.41%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (1 samples, 0.41%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (1 samples, 0.41%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (1 samples, 0.41%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.41%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.41%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.41%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.41%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::add_sparse (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_sparse (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_repetition (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_zero_or_one (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::patch (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::patch (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + regex_automata::meta::regex::Builder::build (15 samples, 6.17%) + + regex_au.. + + + regex_automata::meta::regex::Builder::build_many (15 samples, 6.17%) + + regex_au.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (15 samples, 6.17%) + + regex_au.. + + + regex_automata::meta::strategy::new (15 samples, 6.17%) + + regex_au.. + + + regex_automata::meta::strategy::Core::new (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 4.94%) + + regex_.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.94%) + + <core:.. + + + core::option::Option<T>::map (12 samples, 4.94%) + + core::.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.94%) + + core::.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (12 samples, 4.94%) + + regex_.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.94%) + + <core:.. + + + core::option::Option<T>::map (12 samples, 4.94%) + + core::.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.94%) + + core::.. + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 4.94%) + + regex_.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.94%) + + <core:.. + + + core::option::Option<T>::map (12 samples, 4.94%) + + core::.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.94%) + + core::.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (4 samples, 1.65%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (4 samples, 1.65%) + + + + + core::option::Option<T>::map (4 samples, 1.65%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 1.65%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (4 samples, 1.65%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 1.65%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_literal (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_literal::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_range (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::add_range (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_range (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.41%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.82%) + + + + + regex::builders::bytes::RegexBuilder::build (2 samples, 0.82%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + tcache_put (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (2 samples, 0.82%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (3 samples, 1.23%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + [[kernel.kallsyms]] (4 samples, 1.65%) + + + + + core::ptr::write (5 samples, 2.06%) + + c.. + + + core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.41%) + + + + + <core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.41%) + + + + + core::cmp::impls::<impl core::cmp::PartialOrd for usize>::lt (1 samples, 0.41%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (9 samples, 3.70%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (9 samples, 3.70%) + + <cor.. + + + core::option::Option<T>::map (9 samples, 3.70%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (9 samples, 3.70%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (9 samples, 3.70%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (8 samples, 3.29%) + + reg.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (8 samples, 3.29%) + + reg.. + + + alloc::vec::from_elem (8 samples, 3.29%) + + all.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (8 samples, 3.29%) + + <T .. + + + alloc::vec::Vec<T,A>::extend_with (8 samples, 3.29%) + + all.. + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (2 samples, 0.82%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (2 samples, 0.82%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (2 samples, 0.82%) + + + + + alloc::slice::<impl [T]>::to_vec_in (2 samples, 0.82%) + + + + + alloc::slice::hack::to_vec (2 samples, 0.82%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (2 samples, 0.82%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (2 samples, 0.82%) + + + + + core::intrinsics::copy_nonoverlapping (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (10 samples, 4.12%) + + <cor.. + + + core::option::Option<T>::map (10 samples, 4.12%) + + core.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (10 samples, 4.12%) + + core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (10 samples, 4.12%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (10 samples, 4.12%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (10 samples, 4.12%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + _int_realloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + sysmalloc (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::map::Utf8SuffixMap::clear (1 samples, 0.41%) + + + + + alloc::vec::from_elem (1 samples, 0.41%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + regex::builders::Builder::build_one_bytes (12 samples, 4.94%) + + regex:.. + + + regex_automata::meta::regex::Builder::build (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::regex::Builder::build_many (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::regex::Builder::build_many_from_hir (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::strategy::new (12 samples, 4.94%) + + regex_.. + + + regex_automata::meta::strategy::Core::new (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 4.94%) + + regex_.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.94%) + + <core:.. + + + core::option::Option<T>::map (12 samples, 4.94%) + + core::.. + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.94%) + + core::.. + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.94%) + + regex_.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (12 samples, 4.94%) + + regex_.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class_reverse_with_suffix (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::patch (1 samples, 0.41%) + + + + + core::cell::RefCell<T>::borrow_mut (1 samples, 0.41%) + + + + + core::cell::RefCell<T>::try_borrow_mut (1 samples, 0.41%) + + + + + core::cell::BorrowRefMut::new (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.41%) + + + + + once_cell::imp::initialize_or_wait (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (2 samples, 0.82%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (2 samples, 0.82%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (2 samples, 0.82%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.82%) + + + + + regex::builders::bytes::RegexBuilder::build (2 samples, 0.82%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.41%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.41%) + + + + + alloc::alloc::realloc (1 samples, 0.41%) + + + + + __GI___libc_realloc (1 samples, 0.41%) + + + + + once_cell::imp::OnceCell<T>::initialize (2 samples, 0.82%) + + + + + once_cell::imp::initialize_or_wait (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (2 samples, 0.82%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (2 samples, 0.82%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (2 samples, 0.82%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.82%) + + + + + regex::builders::bytes::RegexBuilder::build (2 samples, 0.82%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::literal_trie::State::add_match (2 samples, 0.82%) + + + + + alloc::vec::Vec<T,A>::push (2 samples, 0.82%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (2 samples, 0.82%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (2 samples, 0.82%) + + + + + alloc::raw_vec::finish_grow (2 samples, 0.82%) + + + + + __GI___libc_malloc (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_union (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + core::ptr::write (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + [[kernel.kallsyms]] (1 samples, 0.41%) + + + + + all (243 samples, 100%) + + + + + gen-1000-3-foob (177 samples, 72.84%) + + gen-1000-3-foob + + + [unknown] (72 samples, 29.63%) + + [unknown] + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (2 samples, 0.82%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (2 samples, 0.82%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.82%) + + + + + regex::builders::bytes::RegexBuilder::build (2 samples, 0.82%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many (2 samples, 0.82%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.82%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.82%) + + + + + core::option::Option<T>::map (2 samples, 0.82%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.82%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.82%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.41%) + + + + + core::option::Option<T>::map (1 samples, 0.41%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.41%) + + + + + regex_automata::nfa::thompson::literal_trie::State::add_match (1 samples, 0.41%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.41%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.41%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.41%) + + + + + __GI___libc_malloc (1 samples, 0.41%) + + + + + _int_malloc (1 samples, 0.41%) + + + + + diff --git a/releases/0.6.71/flamegraph-syslog-tar.svg b/releases/0.6.71/flamegraph-syslog-tar.svg new file mode 100644 index 00000000..81627617 --- /dev/null +++ b/releases/0.6.71/flamegraph-syslog-tar.svg @@ -0,0 +1,4272 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 5000; created 20240416T000853-0700
; s4 ./logs/other/tests/gen-1000-3-foobar.log.tar + + Reset Zoom + Search + + + + _dl_relocate_object (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + _dl_start (2 samples, 0.83%) + + + + + _dl_sysdep_start (2 samples, 0.83%) + + + + + dl_main (2 samples, 0.83%) + + + + + _dl_map_object_deps (1 samples, 0.42%) + + + + + _dl_catch_exception (1 samples, 0.42%) + + + + + openaux (1 samples, 0.42%) + + + + + _dl_map_object (1 samples, 0.42%) + + + + + _dl_load_cache_lookup (1 samples, 0.42%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (1 samples, 0.42%) + + + + + __GI___libc_write (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + std::io::Write::write_all (2 samples, 0.83%) + + + + + <termcolor::LossyStandardStream<W> as std::io::Write>::write (2 samples, 0.83%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.83%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.83%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.83%) + + + + + __GI___libc_write (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.42%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.42%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (1 samples, 0.42%) + + + + + __memrchr_evex (1 samples, 0.42%) + + + + + <termcolor::LossyStandardStream<W> as termcolor::WriteColor>::set_color (2 samples, 0.83%) + + + + + std::io::Write::write_all (2 samples, 0.83%) + + + + + __GI___libc_write (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + <std::io::stdio::Stdout as std::io::Write>::flush (2 samples, 0.83%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::flush (2 samples, 0.83%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (2 samples, 0.83%) + + + + + s4lib::printer::printers::PrinterLogMessage::print_sysline_color (7 samples, 2.92%) + + s4.. + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + std::thread::park (3 samples, 1.25%) + + + + + syscall (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + __sched_yield (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + crossbeam_channel::context::Context::wait_until (16 samples, 6.67%) + + crossbeam.. + + + crossbeam_channel::context::Context::with::{{closure}} (18 samples, 7.50%) + + crossbeam_.. + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::accept (2 samples, 0.83%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (2 samples, 0.83%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (2 samples, 0.83%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (2 samples, 0.83%) + + + + + crossbeam_channel::select::Select::select (21 samples, 8.75%) + + crossbeam_ch.. + + + crossbeam_channel::select::run_select (21 samples, 8.75%) + + crossbeam_ch.. + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (1 samples, 0.42%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (1 samples, 0.42%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (1 samples, 0.42%) + + + + + _start (32 samples, 13.33%) + + _start + + + __libc_start_main@@GLIBC_2.34 (30 samples, 12.50%) + + __libc_start_main@@.. + + + __libc_start_call_main (30 samples, 12.50%) + + __libc_start_call_m.. + + + main (30 samples, 12.50%) + + main + + + std::rt::lang_start_internal (30 samples, 12.50%) + + std::rt::lang_start.. + + + std::rt::lang_start::_{{closure}} (30 samples, 12.50%) + + std::rt::lang_start.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (30 samples, 12.50%) + + std::sys_common::ba.. + + + s4::main (30 samples, 12.50%) + + s4::main + + + s4::processing_loop (30 samples, 12.50%) + + s4::processing_loop + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + tar::archive::EntriesFields::next_entry_raw (1 samples, 0.42%) + + + + + <std::process::ChildStdout as std::io::Read>::read (1 samples, 0.42%) + + + + + read (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + s4::cli_process_args (1 samples, 0.42%) + + + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 0.42%) + + + + + <clap_builder::builder::styled_str::StyledStr as core::convert::From<&str>>::from (1 samples, 0.42%) + + + + + clap_builder::builder::styled_str::StyledStr::none (1 samples, 0.42%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.42%) + + + + + regex_automata::meta::wrappers::Hybrid::new (1 samples, 0.42%) + + + + + regex_automata::hybrid::dfa::Builder::build_from_nfa (1 samples, 0.42%) + + + + + regex_automata::util::determinize::state::State::dead (1 samples, 0.42%) + + + + + [unknown] (4 samples, 1.67%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.42%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.42%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.42%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (6 samples, 2.50%) + + [[.. + + + [[kernel.kallsyms]] (7 samples, 2.92%) + + [[.. + + + [[kernel.kallsyms]] (7 samples, 2.92%) + + [[.. + + + [[kernel.kallsyms]] (8 samples, 3.33%) + + [[k.. + + + [[kernel.kallsyms]] (8 samples, 3.33%) + + [[k.. + + + [[kernel.kallsyms]] (17 samples, 7.08%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (17 samples, 7.08%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (17 samples, 7.08%) + + [[kernel.k.. + + + s4 (54 samples, 22.50%) + + s4 + + + [[kernel.kallsyms]] (18 samples, 7.50%) + + [[kernel.k.. + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + perf-exec (9 samples, 3.75%) + + perf.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + [[kernel.kallsyms]] (9 samples, 3.75%) + + [[ke.. + + + regex_automata::util::pool::inner::Pool<T,F>::get_slow (1 samples, 0.42%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir::{{closure}} (1 samples, 0.42%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::create_cache (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::reset (1 samples, 0.42%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.42%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_pre (1 samples, 0.42%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.42%) + + + + + regex_syntax::hir::Properties::capture (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + regex_syntax::hir::Hir::literal (1 samples, 0.42%) + + + + + regex_syntax::hir::Hir::into_parts (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + regex_syntax::hir::Hir::concat (3 samples, 1.25%) + + + + + regex_syntax::hir::Hir::class (1 samples, 0.42%) + + + + + core::str::converts::from_utf8 (1 samples, 0.42%) + + + + + regex_syntax::hir::Hir::alternation (3 samples, 1.25%) + + + + + regex_syntax::hir::Properties::alternation (3 samples, 1.25%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + alloc::vec::Vec<T,A>::into_boxed_slice (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (2 samples, 0.83%) + + + + + regex_syntax::hir::translate::Translator::translate (20 samples, 8.33%) + + regex_syntax.. + + + regex_syntax::ast::visitor::visit (20 samples, 8.33%) + + regex_syntax.. + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_post (18 samples, 7.50%) + + <regex_syn.. + + + <regex_syntax::ast::parse::NestLimiter<P> as regex_syntax::ast::visitor::Visitor>::visit_pre (1 samples, 0.42%) + + + + + regex_syntax::ast::visitor::visit (2 samples, 0.83%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_group (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_group (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_capture_name (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_alternate (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_group (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_class_open (2 samples, 0.83%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_class_op (2 samples, 0.83%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_class (3 samples, 1.25%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + regex_syntax::ast::ClassSetUnion::push (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_set_class (7 samples, 2.92%) + + re.. + + + regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::ParserI<P>::bump (1 samples, 0.42%) + + + + + malloc (2 samples, 0.83%) + + + + + _int_malloc (2 samples, 0.83%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + regex_syntax::ast::parse::Parser::parse (20 samples, 8.33%) + + regex_syntax.. + + + regex_syntax::ast::parse::ParserI<P>::parse_with_comments (20 samples, 8.33%) + + regex_syntax.. + + + _int_free (2 samples, 0.83%) + + + + + cfree@GLIBC_2.2.5 (3 samples, 1.25%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (5 samples, 2.08%) + + c.. + + + cfree@GLIBC_2.2.5 (2 samples, 0.83%) + + + + + _int_free (2 samples, 0.83%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + unlink_chunk.constprop.0 (1 samples, 0.42%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (9 samples, 3.75%) + + core.. + + + <regex_syntax::ast::Ast as core::ops::drop::Drop>::drop (9 samples, 3.75%) + + <reg.. + + + _int_free (3 samples, 1.25%) + + + + + cfree@GLIBC_2.2.5 (5 samples, 2.08%) + + c.. + + + regex_automata::meta::regex::Builder::build (55 samples, 22.92%) + + regex_automata::meta::regex::Builder.. + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (6 samples, 2.50%) + + <a.. + + + <regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (6 samples, 2.50%) + + <r.. + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.42%) + + + + + regex::builders::Builder::build_one_bytes (56 samples, 23.33%) + + regex::builders::Builder::build_one_b.. + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + once_cell::imp::OnceCell<T>::initialize (58 samples, 24.17%) + + once_cell::imp::OnceCell<T>::initialize + + + once_cell::imp::initialize_or_wait (58 samples, 24.17%) + + once_cell::imp::initialize_or_wait + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (58 samples, 24.17%) + + once_cell::imp::OnceCell<T>::initializ.. + + + regex::regex::bytes::Regex::new (58 samples, 24.17%) + + regex::regex::bytes::Regex::new + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (2 samples, 0.83%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (2 samples, 0.83%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (60 samples, 25.00%) + + s4lib::readers::syslinereader::SyslineRe.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (60 samples, 25.00%) + + s4lib::readers::syslinereader::SyslineRe.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (60 samples, 25.00%) + + s4lib::readers::syslinereader::SyslineRe.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (60 samples, 25.00%) + + s4lib::data::datetime::bytes_to_regex_to.. + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (1 samples, 0.42%) + + + + + regex_automata::hybrid::regex::Regex::try_search (1 samples, 0.42%) + + + + + regex_automata::hybrid::search::find_fwd (1 samples, 0.42%) + + + + + regex_automata::hybrid::dfa::Lazy::cache_next_state (1 samples, 0.42%) + + + + + regex_automata::util::determinize::next (1 samples, 0.42%) + + + + + regex_automata::util::determinize::epsilon_closure (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + std::io::default_read_exact (2 samples, 0.83%) + + + + + <tar::entry::EntryFields as std::io::Read>::read (2 samples, 0.83%) + + + + + <std::io::Take<T> as std::io::Read>::read (2 samples, 0.83%) + + + + + <std::process::ChildStdout as std::io::Read>::read (2 samples, 0.83%) + + + + + read (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (63 samples, 26.25%) + + s4lib::readers::syslogprocessor::SyslogPro.. + + + s4lib::readers::blockreader::BlockReader::read_block (3 samples, 1.25%) + + + + + __libc_calloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + sysmalloc (1 samples, 0.42%) + + + + + __mprotect (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::drop_data_try (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_data (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_sysline (1 samples, 0.42%) + + + + + core::ptr::drop_in_place<core::option::Option<s4lib::common::ResultS3<(u64,alloc::sync::Arc<s4lib::data::sysline::Sysline>),std::io::error::Error>>> (1 samples, 0.42%) + + + + + s4lib::data::line::Line::get_boxptrs (1 samples, 0.42%) + + + + + chrono::naive::datetime::NaiveDateTime::parse_from_str (2 samples, 0.83%) + + + + + chrono::format::parse::parse_internal (2 samples, 0.83%) + + + + + s4lib::data::datetime::datetime_parse_from_str (3 samples, 1.25%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write (1 samples, 0.42%) + + + + + regex_automata::util::captures::Captures::get_group_by_name (2 samples, 0.83%) + + + + + hashbrown::map::make_hash (2 samples, 0.83%) + + + + + regex_automata::meta::regex::Regex::create_captures (1 samples, 0.42%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.42%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::Core::search_slots_nofail (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots_imp (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::search_imp (1 samples, 0.42%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (9 samples, 3.75%) + + s4li.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (11 samples, 4.58%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (13 samples, 5.42%) + + s4lib::.. + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (2 samples, 0.83%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::insert_sysline (2 samples, 0.83%) + + + + + rangemap::map::RangeMap<K,V>::insert (2 samples, 0.83%) + + + + + s4lib::readers::syslinereader::SyslineReader::check_store (2 samples, 0.83%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (2 samples, 0.83%) + + + + + s4lib::readers::linereader::LineReader::get_linep (1 samples, 0.42%) + + + + + s4lib::readers::blockreader::BlockReader::read_block (1 samples, 0.42%) + + + + + lru::LruCache<K,V,S>::put (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_year (27 samples, 11.25%) + + s4lib::readers::s.. + + + s4lib::readers::linereader::LineReader::find_line (10 samples, 4.17%) + + s4lib.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_between_datetime_filters (28 samples, 11.67%) + + s4lib::readers::s.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_at_datetime_filter_binary_search (28 samples, 11.67%) + + s4lib::readers::s.. + + + crossbeam_channel::waker::SyncWaker::notify (1 samples, 0.42%) + + + + + clone3 (96 samples, 40.00%) + + clone3 + + + start_thread (96 samples, 40.00%) + + start_thread + + + std::sys::unix::thread::Thread::new::thread_start (96 samples, 40.00%) + + std::sys::unix::thread::Thread::new::thread_start + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (96 samples, 40.00%) + + core::ops::function::FnOnce::call_once{{vtable.shim}} + + + std::sys_common::backtrace::__rust_begin_short_backtrace (96 samples, 40.00%) + + std::sys_common::backtrace::__rust_begin_short_backtrace + + + s4::exec_fileprocessor_thread (96 samples, 40.00%) + + s4::exec_fileprocessor_thread + + + crossbeam_channel::channel::Sender<T>::send (4 samples, 1.67%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send (4 samples, 1.67%) + + + + + __memmove_avx512_unaligned_erms (3 samples, 1.25%) + + + + + regex_automata::util::prefilter::prefixes (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.42%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + regex_automata::meta::wrappers::BoundedBacktracker::new (1 samples, 0.42%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (1 samples, 0.42%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::range_trie::RangeTrie> (1 samples, 0.42%) + + + + + __rdl_dealloc (1 samples, 0.42%) + + + + + regex_automata::meta::reverse_inner::prefilter (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.42%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (4 samples, 1.67%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (4 samples, 1.67%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (4 samples, 1.67%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (4 samples, 1.67%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (4 samples, 1.67%) + + + + + once_cell::imp::OnceCell<T>::initialize (4 samples, 1.67%) + + + + + once_cell::imp::initialize_or_wait (4 samples, 1.67%) + + + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (4 samples, 1.67%) + + + + + regex::regex::bytes::Regex::new (4 samples, 1.67%) + + + + + regex::builders::Builder::build_one_bytes (4 samples, 1.67%) + + + + + regex_automata::meta::regex::Builder::build (4 samples, 1.67%) + + + + + regex_automata::meta::strategy::new (4 samples, 1.67%) + + + + + regex_automata::meta::reverse_inner::extract (2 samples, 0.83%) + + + + + regex_automata::meta::reverse_inner::flatten (1 samples, 0.42%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.42%) + + + + + regex_automata::meta::reverse_inner::flatten (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::nfa::Inner::remap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::nfa::Inner::add (3 samples, 1.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (5 samples, 2.08%) + + r.. + + + regex_automata::nfa::thompson::builder::Builder::build (5 samples, 2.08%) + + r.. + + + malloc (1 samples, 0.42%) + + + + + regex_automata::meta::wrappers::PikeVM::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::range_trie::RangeTrie::new (1 samples, 0.42%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (7 samples, 2.92%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (7 samples, 2.92%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (7 samples, 2.92%) + + s4.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (7 samples, 2.92%) + + s4.. + + + once_cell::imp::OnceCell<T>::initialize (7 samples, 2.92%) + + on.. + + + once_cell::imp::initialize_or_wait (7 samples, 2.92%) + + on.. + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (7 samples, 2.92%) + + on.. + + + regex::regex::bytes::Regex::new (7 samples, 2.92%) + + re.. + + + regex::builders::Builder::build_one_bytes (7 samples, 2.92%) + + re.. + + + regex_automata::meta::regex::Builder::build (7 samples, 2.92%) + + re.. + + + regex_automata::meta::strategy::new (7 samples, 2.92%) + + re.. + + + regex_automata::meta::reverse_inner::extract (1 samples, 0.42%) + + + + + regex_automata::meta::reverse_inner::prefilter (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.42%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + sysmalloc (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.42%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.42%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.42%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.42%) + + + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (1 samples, 0.42%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.42%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.42%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.42%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (4 samples, 1.67%) + + + + + cfree@GLIBC_2.2.5 (2 samples, 0.83%) + + + + + _int_free (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (7 samples, 2.92%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (8 samples, 3.33%) + + reg.. + + + regex_automata::nfa::thompson::builder::Builder::add_capture_start (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (9 samples, 3.75%) + + rege.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (9 samples, 3.75%) + + <cor.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (9 samples, 3.75%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (9 samples, 3.75%) + + rege.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::builder::Builder::patch (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + regex_automata::dfa::onepass::InternalBuilder::shuffle_states (1 samples, 0.42%) + + + + + regex_automata::dfa::remapper::Remapper::remap (1 samples, 0.42%) + + + + + regex_automata::dfa::remapper::onepass::<impl regex_automata::dfa::remapper::Remappable for regex_automata::dfa::onepass::DFA>::remap (1 samples, 0.42%) + + + + + regex_automata::dfa::onepass::InternalBuilder::compile_transition (2 samples, 0.83%) + + + + + regex_automata::dfa::onepass::InternalBuilder::add_dfa_state_for_nfa_state (2 samples, 0.83%) + + + + + __memset_avx512_unaligned_erms (2 samples, 0.83%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (14 samples, 5.83%) + + s4lib::.. + + + once_cell::imp::OnceCell<T>::initialize (14 samples, 5.83%) + + once_ce.. + + + once_cell::imp::initialize_or_wait (14 samples, 5.83%) + + once_ce.. + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (14 samples, 5.83%) + + once_ce.. + + + regex::regex::bytes::Regex::new (14 samples, 5.83%) + + regex::.. + + + regex::builders::Builder::build_one_bytes (14 samples, 5.83%) + + regex::.. + + + regex_automata::meta::regex::Builder::build (14 samples, 5.83%) + + regex_a.. + + + regex_automata::meta::strategy::new (14 samples, 5.83%) + + regex_a.. + + + regex_automata::meta::wrappers::OnePass::new (5 samples, 2.08%) + + r.. + + + regex_automata::dfa::onepass::Builder::build_from_nfa (5 samples, 2.08%) + + r.. + + + malloc (2 samples, 0.83%) + + + + + _int_malloc (2 samples, 0.83%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (2 samples, 0.83%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (2 samples, 0.83%) + + + + + alloc::vec::Vec<T,A>::retain_mut (2 samples, 0.83%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (2 samples, 0.83%) + + + + + regex_syntax::hir::literal::Extractor::union (1 samples, 0.42%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.42%) + + + + + regex_automata::util::prefilter::prefixes (4 samples, 1.67%) + + + + + regex_syntax::hir::literal::Extractor::extract (2 samples, 0.83%) + + + + + regex_syntax::hir::literal::Extractor::extract (2 samples, 0.83%) + + + + + cfree@GLIBC_2.2.5 (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.42%) + + + + + regex_automata::meta::reverse_inner::extract (1 samples, 0.42%) + + + + + regex_automata::meta::reverse_inner::prefilter (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.42%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.42%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + _int_free (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + unlink_chunk.constprop.0 (1 samples, 0.42%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (9 samples, 3.75%) + + s4li.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (9 samples, 3.75%) + + s4li.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (9 samples, 3.75%) + + s4li.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (9 samples, 3.75%) + + s4li.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (9 samples, 3.75%) + + s4li.. + + + once_cell::imp::OnceCell<T>::initialize (9 samples, 3.75%) + + once.. + + + once_cell::imp::initialize_or_wait (9 samples, 3.75%) + + once.. + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (9 samples, 3.75%) + + once.. + + + regex::regex::bytes::Regex::new (9 samples, 3.75%) + + rege.. + + + regex::builders::Builder::build_one_bytes (9 samples, 3.75%) + + rege.. + + + regex_automata::meta::regex::Builder::build (9 samples, 3.75%) + + rege.. + + + regex_automata::meta::strategy::new (9 samples, 3.75%) + + rege.. + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (2 samples, 0.83%) + + + + + core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::compiler::Utf8State>> (2 samples, 0.83%) + + + + + cfree@GLIBC_2.2.5 (2 samples, 0.83%) + + + + + s4::exec_fileprocessor_thread (10 samples, 4.17%) + + s4::e.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::new (1 samples, 0.42%) + + + + + s4lib::readers::syslinereader::SyslineReader::new (1 samples, 0.42%) + + + + + s4lib::readers::linereader::LineReader::new (1 samples, 0.42%) + + + + + s4lib::readers::blockreader::BlockReader::new (1 samples, 0.42%) + + + + + std::fs::OpenOptions::_open (1 samples, 0.42%) + + + + + std::sys::unix::fs::File::open_c (1 samples, 0.42%) + + + + + __GI___libc_open (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + regex_automata::meta::wrappers::Hybrid::new (1 samples, 0.42%) + + + + + regex_automata::hybrid::dfa::Builder::build_from_nfa (1 samples, 0.42%) + + + + + regex_automata::hybrid::dfa::Config::byte_classes_from_nfa (1 samples, 0.42%) + + + + + aho_corasick::util::alphabet::ByteClassSet::set_range (1 samples, 0.42%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::shuffle (1 samples, 0.42%) + + + + + aho_corasick::util::remapper::Remapper::remap (1 samples, 0.42%) + + + + + <aho_corasick::nfa::noncontiguous::NFA as aho_corasick::util::remapper::Remappable>::remap (1 samples, 0.42%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (3 samples, 1.25%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (3 samples, 1.25%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::new (1 samples, 0.42%) + + + + + aho_corasick::nfa::noncontiguous::NFA::add_transition (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::new (6 samples, 2.50%) + + re.. + + + regex_automata::meta::reverse_inner::extract (5 samples, 2.08%) + + r.. + + + regex_automata::meta::reverse_inner::prefilter (5 samples, 2.08%) + + r.. + + + regex_automata::util::prefilter::Prefilter::new (5 samples, 2.08%) + + r.. + + + regex_automata::util::prefilter::Choice::new (5 samples, 2.08%) + + r.. + + + regex_automata::util::prefilter::aho_corasick::AhoCorasick::new (2 samples, 0.83%) + + + + + aho_corasick::ahocorasick::AhoCorasickBuilder::build (2 samples, 0.83%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (2 samples, 0.83%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::shuffle (1 samples, 0.42%) + + + + + aho_corasick::util::remapper::Remapper::remap (1 samples, 0.42%) + + + + + <aho_corasick::nfa::noncontiguous::NFA as aho_corasick::util::remapper::Remappable>::remap (1 samples, 0.42%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (6 samples, 2.50%) + + re.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (6 samples, 2.50%) + + <T.. + + + alloc::vec::Vec<T,A>::extend_with (6 samples, 2.50%) + + al.. + + + __memmove_avx512_unaligned_erms (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (2 samples, 0.83%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (2 samples, 0.83%) + + + + + alloc::vec::Vec<T,A>::extend_with (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (10 samples, 4.17%) + + regex.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (10 samples, 4.17%) + + <core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 1.67%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (2 samples, 0.83%) + + + + + regex_automata::meta::regex::Builder::build (12 samples, 5.00%) + + regex_.. + + + regex_automata::meta::strategy::new (12 samples, 5.00%) + + regex_.. + + + regex_automata::meta::reverse_inner::extract (2 samples, 0.83%) + + + + + regex_automata::meta::reverse_inner::prefilter (2 samples, 0.83%) + + + + + regex_automata::util::prefilter::Prefilter::new (2 samples, 0.83%) + + + + + regex_automata::util::prefilter::Choice::new (2 samples, 0.83%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (2 samples, 0.83%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (2 samples, 0.83%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + _int_malloc (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (4 samples, 1.67%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (4 samples, 1.67%) + + + + + alloc::raw_vec::finish_grow (4 samples, 1.67%) + + + + + malloc (3 samples, 1.25%) + + + + + regex_automata::nfa::thompson::map::Utf8SuffixMap::clear (1 samples, 0.42%) + + + + + regex::regex::bytes::Regex::new (6 samples, 2.50%) + + re.. + + + regex::builders::Builder::build_one_bytes (6 samples, 2.50%) + + re.. + + + regex_automata::meta::regex::Builder::build (6 samples, 2.50%) + + re.. + + + regex_automata::meta::strategy::new (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (6 samples, 2.50%) + + re.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (6 samples, 2.50%) + + <c.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (6 samples, 2.50%) + + re.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + sysmalloc (1 samples, 0.42%) + + + + + __mprotect (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_exactly (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_syntax::hir::ClassUnicode::is_ascii (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + unlink_chunk.constprop.0 (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.25%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.25%) + + + + + cfree@GLIBC_2.2.5 (2 samples, 0.83%) + + + + + _int_free (2 samples, 0.83%) + + + + + __memmove_avx512_unaligned_erms (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (2 samples, 0.83%) + + + + + [[kernel.kallsyms]] (3 samples, 1.25%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (4 samples, 1.67%) + + + + + [[kernel.kallsyms]] (5 samples, 2.08%) + + [.. + + + [[kernel.kallsyms]] (5 samples, 2.08%) + + [.. + + + [[kernel.kallsyms]] (5 samples, 2.08%) + + [.. + + + regex::builders::Builder::build_one_bytes (15 samples, 6.25%) + + regex::b.. + + + regex_automata::meta::regex::Builder::build (15 samples, 6.25%) + + regex_au.. + + + regex_automata::meta::strategy::new (15 samples, 6.25%) + + regex_au.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (15 samples, 6.25%) + + regex_au.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (15 samples, 6.25%) + + <core::i.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (15 samples, 6.25%) + + regex_au.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (15 samples, 6.25%) + + regex_au.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (15 samples, 6.25%) + + regex_au.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (15 samples, 6.25%) + + regex_au.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (10 samples, 4.17%) + + regex.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (10 samples, 4.17%) + + regex.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (10 samples, 4.17%) + + <T as.. + + + alloc::vec::Vec<T,A>::extend_with (10 samples, 4.17%) + + alloc.. + + + once_cell::imp::initialize_or_wait (2 samples, 0.83%) + + + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (2 samples, 0.83%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.83%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.83%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.83%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.83%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (2 samples, 0.83%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.42%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.42%) + + + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (1 samples, 0.42%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.42%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.42%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.42%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.42%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + malloc (1 samples, 0.42%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.42%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.42%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.42%) + + + + + realloc (1 samples, 0.42%) + + + + + _int_realloc (1 samples, 0.42%) + + + + + _int_malloc (1 samples, 0.42%) + + + + + malloc_consolidate (1 samples, 0.42%) + + + + + once_cell::imp::OnceCell<T>::initialize::_{{closure}} (2 samples, 0.83%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.83%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.83%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.83%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.83%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.83%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.42%) + + + + + <regex_syntax::hir::ClassUnicodeIter as core::iter::traits::iterator::Iterator>::next (1 samples, 0.42%) + + + + + all (240 samples, 100%) + + + + + gen-1000-3-foob (177 samples, 73.75%) + + gen-1000-3-foob + + + [unknown] (81 samples, 33.75%) + + [unknown] + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + [[kernel.kallsyms]] (1 samples, 0.42%) + + + + + diff --git a/releases/0.6.71/flamegraph-syslog-xz.svg b/releases/0.6.71/flamegraph-syslog-xz.svg new file mode 100644 index 00000000..a590d6b3 --- /dev/null +++ b/releases/0.6.71/flamegraph-syslog-xz.svg @@ -0,0 +1,491 @@ +Flame Graph Reset ZoomSearch _dl_unload_cache (1 samples, 0.35%)munmap (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)elf_dynamic_do_Rela (1 samples, 0.35%)elf_machine_rela_relative (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)_dl_relocate_object (2 samples, 0.70%)_dl_protect_relro (1 samples, 0.35%)__mprotect (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)_dl_start (4 samples, 1.41%)_dl_start_final (4 samples, 1.41%)_dl_sysdep_start (4 samples, 1.41%)dl_main (4 samples, 1.41%)_dl_map_object_deps (1 samples, 0.35%)_dl_catch_exception (1 samples, 0.35%)openaux (1 samples, 0.35%)_dl_map_object (1 samples, 0.35%)_dl_map_object_from_fd (1 samples, 0.35%)_dl_map_segments (1 samples, 0.35%)_dl_map_segment (1 samples, 0.35%)__mmap64 (1 samples, 0.35%)__mmap64 (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)std::io::Write::write_all (2 samples, 0.70%)<termcolor::StandardStream as std::io::Write>::write (2 samples, 0.70%)<termcolor::LossyStandardStream<W> as std::io::Write>::write (2 samples, 0.70%)<termcolor::WriterInner<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)<&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::StdoutRaw as std::io::Write>::write (2 samples, 0.70%)<std::sys::unix::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)std::sys::unix::fd::FileDesc::write (2 samples, 0.70%)__GI___libc_write (2 samples, 0.70%)__GI___libc_write (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)s4lib::data::line::LinePart::as_slice (2 samples, 0.70%)std::sys_common::memchr::memrchr (1 samples, 0.35%)std::sys::unix::memchr::memrchr (1 samples, 0.35%)std::sys::unix::memchr::memrchr::memrchr_specific (1 samples, 0.35%)__memrchr_evex (1 samples, 0.35%)termcolor::Ansi<W>::write_str (2 samples, 0.70%)std::io::Write::write_all (2 samples, 0.70%)<termcolor::Ansi<W> as std::io::Write>::write (2 samples, 0.70%)<termcolor::IoStandardStream as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)<&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (2 samples, 0.70%)std::io::buffered::linewritershim::LineWriterShim<W>::flush_if_completed_line (1 samples, 0.35%)std::io::Write::write_all (1 samples, 0.35%)<termcolor::Ansi<W> as std::io::Write>::write (1 samples, 0.35%)<termcolor::IoStandardStream as std::io::Write>::write (1 samples, 0.35%)<std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.35%)<&std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.35%)<std::io::stdio::StdoutLock as std::io::Write>::write (1 samples, 0.35%)<std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (1 samples, 0.35%)<std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (1 samples, 0.35%)<std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (1 samples, 0.35%)std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (1 samples, 0.35%)core::intrinsics::copy_nonoverlapping (1 samples, 0.35%)__memmove_avx512_unaligned_erms (1 samples, 0.35%)<termcolor::StandardStream as termcolor::WriteColor>::set_color (4 samples, 1.41%)<termcolor::LossyStandardStream<W> as termcolor::WriteColor>::set_color (4 samples, 1.41%)<termcolor::WriterInner<W> as termcolor::WriteColor>::set_color (4 samples, 1.41%)<termcolor::Ansi<W> as termcolor::WriteColor>::set_color (4 samples, 1.41%)<termcolor::Ansi<W> as termcolor::WriteColor>::reset (1 samples, 0.35%)termcolor::Ansi<W>::write_str (1 samples, 0.35%)std::io::Write::write_all (1 samples, 0.35%)<termcolor::Ansi<W> as std::io::Write>::write (1 samples, 0.35%)<termcolor::IoStandardStream as std::io::Write>::write (1 samples, 0.35%)<std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.35%)<&std::io::stdio::Stdout as std::io::Write>::write (1 samples, 0.35%)std::io::stdio::Stdout::lock (1 samples, 0.35%)std::sys_common::remutex::ReentrantMutex<T>::lock (1 samples, 0.35%)core::sync::atomic::AtomicUsize::load (1 samples, 0.35%)core::sync::atomic::atomic_load (1 samples, 0.35%)s4lib::printer::printers::PrinterLogMessage::print_sysline (9 samples, 3.17%)s4l..s4lib::printer::printers::PrinterLogMessage::print_sysline_color (9 samples, 3.17%)s4l..<termcolor::StandardStream as std::io::Write>::flush (1 samples, 0.35%)<std::io::stdio::Stdout as std::io::Write>::flush (1 samples, 0.35%)<&std::io::stdio::Stdout as std::io::Write>::flush (1 samples, 0.35%)<std::io::stdio::StdoutLock as std::io::Write>::flush (1 samples, 0.35%)<std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::flush (1 samples, 0.35%)<std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::flush (1 samples, 0.35%)std::io::buffered::bufwriter::BufWriter<W>::flush_buf (1 samples, 0.35%)<std::io::stdio::StdoutRaw as std::io::Write>::write (1 samples, 0.35%)<std::sys::unix::stdio::Stdout as std::io::Write>::write (1 samples, 0.35%)std::sys::unix::fd::FileDesc::write (1 samples, 0.35%)__GI___libc_write (1 samples, 0.35%)__GI___libc_write (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)crossbeam_channel::channel::read (2 samples, 0.70%)__memmove_avx512_unaligned_erms (2 samples, 0.70%)crossbeam_channel::select::SelectedOperation::recv (3 samples, 1.06%)core::result::Result<T,E>::map_err (1 samples, 0.35%)core::hint::spin_loop (12 samples, 4.23%)core:..core::core_arch::x86::sse2::_mm_pause (12 samples, 4.23%)core:..crossbeam_channel::context::Context::wait_until (13 samples, 4.58%)cross..crossbeam_utils::backoff::Backoff::snooze (13 samples, 4.58%)cross..__GI___sched_yield (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)<crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::unregister (1 samples, 0.35%)<crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::unregister (1 samples, 0.35%)crossbeam_channel::waker::SyncWaker::unregister (1 samples, 0.35%)std::sync::mutex::Mutex<T>::lock (1 samples, 0.35%)std::sys::unix::locks::futex_mutex::Mutex::lock (1 samples, 0.35%)crossbeam_channel::select::run_select::{{closure}} (15 samples, 5.28%)crossb..<crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (1 samples, 0.35%)<crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (1 samples, 0.35%)crossbeam_channel::waker::SyncWaker::register (1 samples, 0.35%)std::sync::mutex::Mutex<T>::lock (1 samples, 0.35%)std::sys::unix::locks::futex_mutex::Mutex::lock (1 samples, 0.35%)crossbeam_channel::context::Context::with::{{closure}} (16 samples, 5.63%)crossbe..crossbeam_channel::context::Context::with::{{closure}} (16 samples, 5.63%)crossbe..crossbeam_channel::context::Context::with (17 samples, 5.99%)crossbea..std::thread::local::LocalKey<T>::try_with (17 samples, 5.99%)std::thr..crossbeam_channel::select::Select::select (18 samples, 6.34%)crossbea..crossbeam_channel::select::select (18 samples, 6.34%)crossbea..crossbeam_channel::select::run_select (18 samples, 6.34%)crossbea..<crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.35%)<crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.35%)crossbeam_channel::flavors::array::Channel<T>::start_recv (1 samples, 0.35%)core::sync::atomic::AtomicUsize::load (1 samples, 0.35%)core::sync::atomic::atomic_load (1 samples, 0.35%)s4::processing_loop::recv_many_chan (22 samples, 7.75%)s4::process..__memmove_avx512_unaligned_erms (1 samples, 0.35%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (1 samples, 0.35%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (1 samples, 0.35%)s4::processing_loop (33 samples, 11.62%)s4::processing_lo..alloc::collections::btree::map::BTreeMap<K,V,A>::remove (2 samples, 0.70%)alloc::collections::btree::map::BTreeMap<K,V,A>::remove_entry (2 samples, 0.70%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (2 samples, 0.70%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (2 samples, 0.70%)regex::regex::string::Regex::captures (1 samples, 0.35%)regex::regex::string::Regex::captures_at (1 samples, 0.35%)regex_automata::meta::regex::Regex::search_captures (1 samples, 0.35%)regex_automata::meta::regex::Regex::search_slots (1 samples, 0.35%)regex_automata::meta::regex::RegexInfo::is_impossible (1 samples, 0.35%)regex_automata::meta::regex::RegexInfo::props_union (1 samples, 0.35%)_start (39 samples, 13.73%)_start__libc_start_main_impl (35 samples, 12.32%)__libc_start_main_..__libc_start_call_main (35 samples, 12.32%)__libc_start_call_..main (35 samples, 12.32%)mainstd::rt::lang_start_internal (35 samples, 12.32%)std::rt::lang_star..std::panic::catch_unwind (35 samples, 12.32%)std::panic::catch_..std::panicking::try (35 samples, 12.32%)std::panicking::trystd::panicking::try::do_call (35 samples, 12.32%)std::panicking::tr..std::rt::lang_start_internal::{{closure}} (35 samples, 12.32%)std::rt::lang_star..std::panic::catch_unwind (35 samples, 12.32%)std::panic::catch_..std::panicking::try (35 samples, 12.32%)std::panicking::trystd::panicking::try::do_call (35 samples, 12.32%)std::panicking::tr..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (35 samples, 12.32%)core::ops::functio..std::rt::lang_start::{{closure}} (35 samples, 12.32%)std::rt::lang_star..std::sys_common::backtrace::__rust_begin_short_backtrace (35 samples, 12.32%)std::sys_common::b..core::ops::function::FnOnce::call_once (35 samples, 12.32%)core::ops::functio..s4::main (35 samples, 12.32%)s4::mains4::cli_process_args (2 samples, 0.70%)s4::string_wdhms_to_duration (2 samples, 0.70%)<s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref (1 samples, 0.35%)<s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__stability (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get (1 samples, 0.35%)std::sync::once::Once::call_once (1 samples, 0.35%)std::sys_common::once::futex::Once::call (1 samples, 0.35%)std::sync::once::Once::call_once::{{closure}} (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)<s4::REGEX_DUR_OFFSET as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.35%)regex::regex::string::Regex::new (1 samples, 0.35%)regex::builders::string::RegexBuilder::build (1 samples, 0.35%)regex::builders::Builder::build_one_string (1 samples, 0.35%)regex_automata::meta::regex::Builder::build (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many (1 samples, 0.35%)regex_syntax::hir::translate::Translator::translate (1 samples, 0.35%)regex_syntax::ast::visitor::visit (1 samples, 0.35%)regex_syntax::ast::visitor::HeapVisitor::visit (1 samples, 0.35%)regex_syntax::ast::visitor::HeapVisitor::induct (1 samples, 0.35%)regex_syntax::ast::visitor::HeapVisitor::visit_class (1 samples, 0.35%)regex_syntax::ast::visitor::HeapVisitor::visit_class_post (1 samples, 0.35%)<regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_class_set_item_post (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::hir_perl_unicode_class (1 samples, 0.35%)regex_syntax::unicode::perl_digit (1 samples, 0.35%)regex_syntax::unicode::perl_digit::imp (1 samples, 0.35%)regex_syntax::unicode::hir_class (1 samples, 0.35%)core::iter::traits::iterator::Iterator::collect (1 samples, 0.35%)<alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)core::iter::traits::iterator::Iterator::fold (1 samples, 0.35%)core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each::call::{{closure}} (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted::{{closure}} (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)__clone3 (1 samples, 0.35%)start_thread (1 samples, 0.35%)std::sys::unix::thread::Thread::new::thread_start (1 samples, 0.35%)std::sys::unix::stack_overflow::Handler::new (1 samples, 0.35%)std::sys::unix::stack_overflow::imp::make_handler (1 samples, 0.35%)std::sys::unix::stack_overflow::imp::get_stack (1 samples, 0.35%)std::sys::unix::stack_overflow::imp::get_stackp (1 samples, 0.35%)__GI___mprotect (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)regex_automata::meta::regex::Builder::build (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.35%)regex_automata::meta::strategy::new (1 samples, 0.35%)regex_automata::meta::strategy::Core::new (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 0.35%)regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.35%)alloc::vec::from_elem (1 samples, 0.35%)<T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_with (1 samples, 0.35%)core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.35%)<core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::PartialOrd for usize>::lt (1 samples, 0.35%)<s4::CLI_Args as clap_builder::derive::Args>::augment_args (1 samples, 0.35%)<once_cell::sync::Lazy<T,F> as core::ops::deref::Deref>::deref (1 samples, 0.35%)once_cell::sync::Lazy<T,F>::force (1 samples, 0.35%)once_cell::sync::OnceCell<T>::get_or_init (1 samples, 0.35%)once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize (1 samples, 0.35%)once_cell::imp::initialize_or_wait (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.35%)once_cell::sync::OnceCell<T>::get_or_init::{{closure}} (1 samples, 0.35%)once_cell::sync::Lazy<T,F>::force::{{closure}} (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)<s4::CLI_Args as clap_builder::derive::Args>::augment_args::DEFAULT_VALUE::{{closure}} (1 samples, 0.35%)<s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref (1 samples, 0.35%)<s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref::__stability (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get (1 samples, 0.35%)std::sync::once::Once::call_once (1 samples, 0.35%)std::sys_common::once::futex::Once::call (1 samples, 0.35%)std::sync::once::Once::call_once::{{closure}} (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)<s4::LOCAL_NOW_OFFSET as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.35%)<s4::LOCAL_NOW as core::ops::deref::Deref>::deref (1 samples, 0.35%)<s4::LOCAL_NOW as core::ops::deref::Deref>::deref::__stability (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get (1 samples, 0.35%)std::sync::once::Once::call_once (1 samples, 0.35%)std::sys_common::once::futex::Once::call (1 samples, 0.35%)std::sync::once::Once::call_once::{{closure}} (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)<s4::LOCAL_NOW as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.35%)<s4::UTC_NOW as core::ops::deref::Deref>::deref (1 samples, 0.35%)<s4::UTC_NOW as core::ops::deref::Deref>::deref::__stability (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get (1 samples, 0.35%)std::sync::once::Once::call_once (1 samples, 0.35%)std::sys_common::once::futex::Once::call (1 samples, 0.35%)std::sync::once::Once::call_once::{{closure}} (1 samples, 0.35%)lazy_static::lazy::Lazy<T>::get::{{closure}} (1 samples, 0.35%)core::ops::function::FnOnce::call_once (1 samples, 0.35%)<s4::UTC_NOW as core::ops::deref::Deref>::deref::__static_ref_initialize (1 samples, 0.35%)chrono::offset::utc::Utc::now (1 samples, 0.35%)std::sys::unix::time::inner::<impl std::sys::unix::time::Timespec>::now (1 samples, 0.35%)__GI___clock_gettime (1 samples, 0.35%)__vdso_clock_gettime (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[unknown] (4 samples, 1.41%)<&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 0.70%)<std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (2 samples, 0.70%)<std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (2 samples, 0.70%)std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (2 samples, 0.70%)core::intrinsics::copy_nonoverlapping (2 samples, 0.70%)__GI___libc_write (2 samples, 0.70%)__GI___libc_write (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (5 samples, 1.76%)[[kernel.kallsyms]] (6 samples, 2.11%)[..[[kernel.kallsyms]] (7 samples, 2.46%)[[..[[kernel.kallsyms]] (7 samples, 2.46%)[[..[[kernel.kallsyms]] (7 samples, 2.46%)[[..[[kernel.kallsyms]] (8 samples, 2.82%)[[..[[kernel.kallsyms]] (8 samples, 2.82%)[[..[[kernel.kallsyms]] (17 samples, 5.99%)[[kernel..[[kernel.kallsyms]] (17 samples, 5.99%)[[kernel..[[kernel.kallsyms]] (17 samples, 5.99%)[[kernel..[[kernel.kallsyms]] (17 samples, 5.99%)[[kernel..[[kernel.kallsyms]] (17 samples, 5.99%)[[kernel..s4 (62 samples, 21.83%)s4[[heap]] (1 samples, 0.35%)__GI___libc_write (1 samples, 0.35%)__GI___libc_write (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)perf-exec (10 samples, 3.52%)per..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..[[kernel.kallsyms]] (10 samples, 3.52%)[[k..regex_automata::util::pool::Pool<T,F>::get (1 samples, 0.35%)regex_automata::util::pool::inner::Pool<T,F>::get (1 samples, 0.35%)regex_automata::util::pool::inner::Pool<T,F>::get_slow (1 samples, 0.35%)<alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many_from_hir::{{closure}} (1 samples, 0.35%)<regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::create_cache (1 samples, 0.35%)regex_automata::meta::wrappers::PikeVM::create_cache (1 samples, 0.35%)regex_automata::meta::wrappers::PikeVMCache::new (1 samples, 0.35%)regex_automata::nfa::thompson::pikevm::PikeVM::create_cache (1 samples, 0.35%)regex_automata::nfa::thompson::pikevm::Cache::new (1 samples, 0.35%)regex_automata::nfa::thompson::pikevm::ActiveStates::new (1 samples, 0.35%)regex_automata::nfa::thompson::pikevm::ActiveStates::reset (1 samples, 0.35%)regex_automata::nfa::thompson::pikevm::SlotTable::reset (1 samples, 0.35%)alloc::vec::Vec<T,A>::resize (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_with (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)regex::regex::bytes::Regex::captures (2 samples, 0.70%)regex::regex::bytes::Regex::captures_at (2 samples, 0.70%)regex_automata::meta::regex::Regex::captures (2 samples, 0.70%)regex_automata::meta::regex::Regex::search_captures (2 samples, 0.70%)regex_automata::meta::regex::Regex::search_slots (2 samples, 0.70%)<regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (1 samples, 0.35%)regex_automata::meta::strategy::Core::try_search_mayfail (1 samples, 0.35%)regex_automata::meta::wrappers::HybridEngine::try_search (1 samples, 0.35%)regex_automata::hybrid::regex::Regex::try_search (1 samples, 0.35%)regex_automata::hybrid::dfa::DFA::try_search_fwd (1 samples, 0.35%)regex_automata::hybrid::search::find_fwd (1 samples, 0.35%)regex_automata::hybrid::search::find_fwd_imp (1 samples, 0.35%)regex_automata::hybrid::dfa::DFA::next_state (1 samples, 0.35%)regex_automata::hybrid::dfa::Lazy::cache_next_state (1 samples, 0.35%)regex_automata::util::determinize::next (1 samples, 0.35%)regex::builders::bytes::RegexBuilder::new (1 samples, 0.35%)regex::builders::Builder::new (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)<core::array::iter::IntoIter<T,_> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)<core::iter::adapters::by_ref_sized::ByRefSized<I> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)core::iter::traits::iterator::Iterator::try_fold (1 samples, 0.35%)<core::const_closure::ConstFnMutClosure<&mut A,Function> as core::ops::function::FnMut<ClosureArguments>>::call_mut (1 samples, 0.35%)core::ops::function::Fn::call (1 samples, 0.35%)core::ops::try_trait::NeverShortCircuit<T>::wrap_mut_2_imp (1 samples, 0.35%)<core::array::iter::IntoIter<T,_> as core::iter::traits::iterator::Iterator>::fold::{{closure}} (1 samples, 0.35%)core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.35%)regex::builders::Builder::new::{{closure}} (1 samples, 0.35%)<str as alloc::string::ToString>::to_string (1 samples, 0.35%)<alloc::string::String as core::convert::From<&str>>::from (1 samples, 0.35%)alloc::str::<impl alloc::borrow::ToOwned for str>::to_owned (1 samples, 0.35%)alloc::slice::<impl alloc::borrow::ToOwned for [T]>::to_owned (1 samples, 0.35%)alloc::slice::<impl [T]>::to_vec (1 samples, 0.35%)alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.35%)alloc::slice::hack::to_vec (1 samples, 0.35%)<T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.35%)alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::hir_ascii_unicode_class (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::unicode_fold_and_negate (1 samples, 0.35%)regex_syntax::ast::visitor::HeapVisitor::induct (2 samples, 0.70%)regex_syntax::ast::visitor::HeapVisitor::visit_class (2 samples, 0.70%)regex_syntax::ast::visitor::HeapVisitor::visit_class_post (2 samples, 0.70%)<regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_class_set_item_post (2 samples, 0.70%)__GI___libc_free (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::push_char (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::append_elements (1 samples, 0.35%)core::ptr::mut_ptr::<impl *mut T>::add (1 samples, 0.35%)core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.35%)regex_syntax::hir::Properties::literal (1 samples, 0.35%)core::str::converts::from_utf8 (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::pop_concat_expr (2 samples, 0.70%)regex_syntax::hir::Hir::literal (2 samples, 0.70%)<T as core::convert::Into<U>>::into (1 samples, 0.35%)alloc::vec::<impl core::convert::From<alloc::vec::Vec<T,A>> for alloc::boxed::Box<[T],A>>::from (1 samples, 0.35%)alloc::vec::Vec<T,A>::into_boxed_slice (1 samples, 0.35%)alloc::vec::Vec<T,A>::shrink_to_fit (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::shrink_to_fit (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::shrink (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::shrink (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)regex_syntax::hir::translate::TranslatorI::case_fold_char (1 samples, 0.35%)regex_syntax::hir::ClassUnicode::try_case_fold_simple (1 samples, 0.35%)regex_syntax::hir::interval::IntervalSet<I>::case_fold_simple (1 samples, 0.35%)<regex_syntax::hir::ClassUnicodeRange as regex_syntax::hir::interval::Interval>::case_fold_simple (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)_int_realloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)tcache_put (1 samples, 0.35%)regex_syntax::hir::Hir::into_parts (1 samples, 0.35%)regex_syntax::hir::Properties::empty (1 samples, 0.35%)alloc::boxed::Box<T>::new (1 samples, 0.35%)alloc::alloc::exchange_malloc (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<regex_syntax::hir::Hir>> (2 samples, 0.70%)<alloc::vec::into_iter::IntoIter<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)alloc::vec::into_iter::IntoIter<T,A>::as_raw_mut_slice (1 samples, 0.35%)regex_syntax::hir::Hir::concat (4 samples, 1.41%)__GI___libc_free (1 samples, 0.35%)core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.35%)regex_syntax::hir::Hir::alternation (2 samples, 0.70%)regex_syntax::hir::Hir::into_parts (2 samples, 0.70%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)<regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_post (14 samples, 4.93%)<regex..alloc::vec::Vec<T,A>::push (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)regex_syntax::hir::translate::Translator::translate (18 samples, 6.34%)regex_sy..regex_syntax::ast::visitor::visit (18 samples, 6.34%)regex_sy..regex_syntax::ast::visitor::HeapVisitor::visit (18 samples, 6.34%)regex_sy..<regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_alternation_in (2 samples, 0.70%)regex_syntax::hir::translate::TranslatorI::push (2 samples, 0.70%)_int_malloc (2 samples, 0.70%)alloc::alloc::exchange_malloc (5 samples, 1.76%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (5 samples, 1.76%)alloc::alloc::Global::alloc_impl (5 samples, 1.76%)alloc::alloc::alloc (5 samples, 1.76%)__GI___libc_malloc (5 samples, 1.76%)regex_syntax::ast::parse::Primitive::into_ast (6 samples, 2.11%)r..regex_syntax::ast::Ast::literal (6 samples, 2.11%)r..alloc::boxed::Box<T>::new (6 samples, 2.11%)a..regex_syntax::ast::parse::ParserI<P>::parse_flags (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::parse_flag (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::push_group (2 samples, 0.70%)regex_syntax::ast::parse::ParserI<P>::parse_group (2 samples, 0.70%)regex_syntax::ast::parse::ParserI<P>::parse_capture_name (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::add_capture_name (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by_key (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by_key::{{closure}} (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::Ord for &A>::cmp (1 samples, 0.35%)core::str::traits::<impl core::cmp::Ord for str>::cmp (1 samples, 0.35%)core::slice::cmp::<impl core::cmp::Ord for [T]>::cmp (1 samples, 0.35%)<u8 as core::slice::cmp::SliceOrd>::compare (1 samples, 0.35%)__memcmp_evex_movbe (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::push_alternate (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::parse_set_class_open (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::span (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::pos (1 samples, 0.35%)core::cell::Cell<T>::get (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)__memmove_avx512_unaligned_erms (1 samples, 0.35%)malloc_consolidate (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::push_class_open (4 samples, 1.41%)alloc::vec::Vec<T,A>::push (3 samples, 1.06%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (2 samples, 0.70%)alloc::raw_vec::RawVec<T,A>::grow_amortized (2 samples, 0.70%)alloc::raw_vec::finish_grow (2 samples, 0.70%)__GI___libc_malloc (2 samples, 0.70%)_int_malloc (2 samples, 0.70%)regex_syntax::ast::parse::ParserI<P>::parse_set_class (5 samples, 1.76%)regex_syntax::ast::parse::ParserI<P>::maybe_parse_ascii_class (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::bump (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::is_eof (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::char_at (1 samples, 0.35%)<core::str::iter::Chars as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::str::validations::next_code_point (1 samples, 0.35%)regex_syntax::ast::parse::ParserI<P>::parse_primitive (2 samples, 0.70%)regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (2 samples, 0.70%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (2 samples, 0.70%)alloc::raw_vec::RawVec<T,A>::grow_amortized (2 samples, 0.70%)alloc::raw_vec::finish_grow (2 samples, 0.70%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)_int_realloc (1 samples, 0.35%)__memmove_avx512_unaligned_erms (1 samples, 0.35%)<core::result::Result<T,E> as core::ops::try_trait::Try>::branch (2 samples, 0.70%)regex_syntax::ast::parse::Parser::parse (22 samples, 7.75%)regex_synta..regex_syntax::ast::parse::ParserI<P>::parse (22 samples, 7.75%)regex_synta..regex_syntax::ast::parse::ParserI<P>::parse_with_comments (22 samples, 7.75%)regex_synta..core::ptr::drop_in_place<regex_syntax::hir::Properties> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::hir::PropertiesI>> (1 samples, 0.35%)alloc::alloc::box_free (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)core::ptr::drop_in_place<regex_syntax::hir::Hir> (2 samples, 0.70%)core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::hir::Hir>> (1 samples, 0.35%)core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.35%)core::ptr::drop_in_place<regex_syntax::hir::Properties> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::hir::PropertiesI>> (1 samples, 0.35%)alloc::alloc::box_free (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::hir::Hir>> (3 samples, 1.06%)<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (3 samples, 1.06%)core::ptr::drop_in_place<[regex_syntax::hir::Hir]> (3 samples, 1.06%)core::ptr::drop_in_place<regex_syntax::hir::Hir> (3 samples, 1.06%)<regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (3 samples, 1.06%)_int_free (1 samples, 0.35%)__GI___libc_free (2 samples, 0.70%)core::ptr::drop_in_place<regex_syntax::ast::Ast> (4 samples, 1.41%)<regex_syntax::ast::Ast as core::ops::drop::Drop>::drop (2 samples, 0.70%)malloc_consolidate (2 samples, 0.70%)core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::ClassBracketed>> (3 samples, 1.06%)core::ptr::drop_in_place<regex_syntax::ast::ClassBracketed> (3 samples, 1.06%)core::ptr::drop_in_place<regex_syntax::ast::ClassSet> (3 samples, 1.06%)<regex_syntax::ast::ClassSet as core::ops::drop::Drop>::drop (3 samples, 1.06%)<alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (3 samples, 1.06%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (3 samples, 1.06%)alloc::vec::Vec<T,A>::extend_trusted (3 samples, 1.06%)alloc::vec::Vec<T,A>::reserve (3 samples, 1.06%)alloc::raw_vec::RawVec<T,A>::reserve (3 samples, 1.06%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (3 samples, 1.06%)alloc::raw_vec::RawVec<T,A>::grow_amortized (3 samples, 1.06%)alloc::raw_vec::finish_grow (3 samples, 1.06%)<alloc::alloc::Global as core::alloc::Allocator>::grow (3 samples, 1.06%)alloc::alloc::Global::grow_impl (3 samples, 1.06%)alloc::alloc::realloc (3 samples, 1.06%)__GI___libc_realloc (3 samples, 1.06%)_int_realloc (3 samples, 1.06%)_int_malloc (3 samples, 1.06%)_int_free (3 samples, 1.06%)__GI___libc_free (4 samples, 1.41%)s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (58 samples, 20.42%)s4lib::readers::syslogprocessor:..s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (58 samples, 20.42%)s4lib::readers::syslogprocessor:..s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (58 samples, 20.42%)s4lib::readers::syslogprocessor:..s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (58 samples, 20.42%)s4lib::readers::syslinereader::S..s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (58 samples, 20.42%)s4lib::readers::syslinereader::S..s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (58 samples, 20.42%)s4lib::readers::syslinereader::S..s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (58 samples, 20.42%)s4lib::readers::syslinereader::S..s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (58 samples, 20.42%)s4lib::readers::syslinereader::S..s4lib::data::datetime::bytes_to_regex_to_datetime (58 samples, 20.42%)s4lib::data::datetime::bytes_to_..once_cell::sync::OnceCell<T>::get_or_try_init (56 samples, 19.72%)once_cell::sync::OnceCell<T>::g..once_cell::imp::OnceCell<T>::initialize (56 samples, 19.72%)once_cell::imp::OnceCell<T>::in..once_cell::imp::initialize_or_wait (56 samples, 19.72%)once_cell::imp::initialize_or_w..core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (56 samples, 19.72%)core::ops::function::impls::<im..once_cell::imp::OnceCell<T>::initialize::{{closure}} (56 samples, 19.72%)once_cell::imp::OnceCell<T>::in..s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (56 samples, 19.72%)s4lib::data::datetime::bytes_to..regex::regex::bytes::Regex::new (56 samples, 19.72%)regex::regex::bytes::Regex::newregex::builders::bytes::RegexBuilder::build (55 samples, 19.37%)regex::builders::bytes::RegexB..regex::builders::Builder::build_one_bytes (55 samples, 19.37%)regex::builders::Builder::buil..regex_automata::meta::regex::Builder::build (55 samples, 19.37%)regex_automata::meta::regex::B..regex_automata::meta::regex::Builder::build_many (55 samples, 19.37%)regex_automata::meta::regex::B..core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::ast::Ast>> (12 samples, 4.23%)core:..<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (12 samples, 4.23%)<allo..core::ptr::drop_in_place<[regex_syntax::ast::Ast]> (12 samples, 4.23%)core:..core::ptr::drop_in_place<regex_syntax::ast::Ast> (12 samples, 4.23%)core:..<regex_syntax::ast::Ast as core::ops::drop::Drop>::drop (12 samples, 4.23%)<rege..<regex_syntax::ast::Ast as core::ops::drop::Drop>::drop::{{closure}} (1 samples, 0.35%)regex_syntax::ast::Ast::empty (1 samples, 0.35%)alloc::boxed::Box<T>::new (1 samples, 0.35%)alloc::alloc::exchange_malloc (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::is_sysline_last (1 samples, 0.35%)<alloc::sync::Arc<T> as core::ops::deref::Deref>::deref (1 samples, 0.35%)alloc::sync::Arc<T>::inner (1 samples, 0.35%)core::ptr::non_null::NonNull<T>::as_ref (1 samples, 0.35%)s4lib::data::line::LinePart::block_boxptr_ab (1 samples, 0.35%)alloc::boxed::Box<T>::new (1 samples, 0.35%)alloc::alloc::exchange_malloc (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)tcache_put (1 samples, 0.35%)s4lib::data::line::Line::get_boxptrs (2 samples, 0.70%)s4lib::data::datetime::u8_to_str (1 samples, 0.35%)core::slice::ascii::<impl [u8]>::is_ascii (1 samples, 0.35%)core::slice::ascii::is_ascii (1 samples, 0.35%)chrono::offset::TimeZone::from_local_datetime (1 samples, 0.35%)chrono::offset::LocalResult<T>::and_then (1 samples, 0.35%)chrono::offset::LocalResult::Single (1 samples, 0.35%)s4lib::data::datetime::datetime_parse_from_str (3 samples, 1.06%)chrono::naive::datetime::NaiveDateTime::parse_from_str (2 samples, 0.70%)chrono::format::parse::parse (2 samples, 0.70%)chrono::format::parse::parse_internal (2 samples, 0.70%)regex_automata::util::captures::Captures::get_group_by_name (1 samples, 0.35%)regex_automata::util::captures::GroupInfo::to_index (1 samples, 0.35%)std::collections::hash::map::HashMap<K,V,S>::get (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::get (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::get_inner (1 samples, 0.35%)hashbrown::map::make_hash (1 samples, 0.35%)core::hash::BuildHasher::hash_one (1 samples, 0.35%)core::hash::impls::<impl core::hash::Hash for &T>::hash (1 samples, 0.35%)core::hash::impls::<impl core::hash::Hash for str>::hash (1 samples, 0.35%)<std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write_str (1 samples, 0.35%)<core::hash::sip::SipHasher13 as core::hash::Hasher>::write_str (1 samples, 0.35%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write_str (1 samples, 0.35%)core::hash::Hasher::write_u8 (1 samples, 0.35%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (1 samples, 0.35%)regex::regex::bytes::Captures::name (2 samples, 0.70%)s4lib::data::datetime::captures_to_buffer_bytes (3 samples, 1.06%)regex_automata::meta::regex::RegexInfo::is_impossible (1 samples, 0.35%)regex_automata::meta::strategy::Core::search_slots_nofail (1 samples, 0.35%)regex_automata::meta::wrappers::BoundedBacktrackerEngine::search_slots (1 samples, 0.35%)regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots (1 samples, 0.35%)regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots_imp (1 samples, 0.35%)regex_automata::nfa::thompson::backtrack::BoundedBacktracker::search_imp (1 samples, 0.35%)regex_automata::nfa::thompson::backtrack::BoundedBacktracker::backtrack (1 samples, 0.35%)regex_automata::nfa::thompson::backtrack::BoundedBacktracker::step (1 samples, 0.35%)regex_automata::nfa::thompson::nfa::SparseTransitions::matches (1 samples, 0.35%)core::option::Option<T>::and_then (1 samples, 0.35%)regex_automata::nfa::thompson::nfa::SparseTransitions::matches::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::nfa::SparseTransitions::matches_byte (1 samples, 0.35%)regex::regex::bytes::Regex::captures (3 samples, 1.06%)regex::regex::bytes::Regex::captures_at (3 samples, 1.06%)regex_automata::meta::regex::Regex::captures (3 samples, 1.06%)regex_automata::meta::regex::Regex::search_captures (3 samples, 1.06%)regex_automata::meta::regex::Regex::search_slots (3 samples, 1.06%)<regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (2 samples, 0.70%)core::hash::impls::<impl core::hash::Hash for &T>::hash (1 samples, 0.35%)core::hash::impls::<impl core::hash::Hash for str>::hash (1 samples, 0.35%)<std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write_str (1 samples, 0.35%)<core::hash::sip::SipHasher13 as core::hash::Hasher>::write_str (1 samples, 0.35%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write_str (1 samples, 0.35%)core::hash::Hasher::write_u8 (1 samples, 0.35%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (1 samples, 0.35%)core::hash::sip::u8to64_le (1 samples, 0.35%)regex::regex::bytes::Captures::name (2 samples, 0.70%)regex_automata::util::captures::Captures::get_group_by_name (2 samples, 0.70%)regex_automata::util::captures::GroupInfo::to_index (2 samples, 0.70%)std::collections::hash::map::HashMap<K,V,S>::get (2 samples, 0.70%)hashbrown::map::HashMap<K,V,S,A>::get (2 samples, 0.70%)hashbrown::map::HashMap<K,V,S,A>::get_inner (2 samples, 0.70%)hashbrown::map::make_hash (2 samples, 0.70%)core::hash::BuildHasher::hash_one (2 samples, 0.70%)<std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (1 samples, 0.35%)<core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (1 samples, 0.35%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (1 samples, 0.35%)<core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::d_rounds (1 samples, 0.35%)core::num::<impl u64>::rotate_left (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (15 samples, 5.28%)s4lib:..s4lib::data::datetime::bytes_to_regex_to_datetime (13 samples, 4.58%)s4lib..__rust_dealloc (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (16 samples, 5.63%)s4lib::..itertools::Itertools::sorted_by (1 samples, 0.35%)<alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (1 samples, 0.35%)alloc::vec::Vec<T>::with_capacity (1 samples, 0.35%)alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)lru::LruCache<K,V,S>::detach (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (18 samples, 6.34%)s4lib::r..lru::LruCache<K,V,S>::get (2 samples, 0.70%)hashbrown::map::HashMap<K,V,S,A>::get_mut (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (1 samples, 0.35%)rangemap::map::RangeMap<K,V>::insert (1 samples, 0.35%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (1 samples, 0.35%)alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::split (1 samples, 0.35%)alloc::collections::btree::node::LeafNode<K,V>::new (1 samples, 0.35%)alloc::boxed::Box<T,A>::new_uninit_in (1 samples, 0.35%)alloc::boxed::Box<T,A>::try_new_uninit_in (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::insert_sysline (2 samples, 0.70%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (1 samples, 0.35%)alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert (1 samples, 0.35%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::split (1 samples, 0.35%)alloc::collections::btree::node::LeafNode<K,V>::new (1 samples, 0.35%)alloc::boxed::Box<T,A>::new_uninit_in (1 samples, 0.35%)alloc::boxed::Box<T,A>::try_new_uninit_in (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::check_store (1 samples, 0.35%)lru::LruCache<K,V,S>::get (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::get_mut (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (1 samples, 0.35%)hashbrown::raw::RawTable<T,A>::get_mut (1 samples, 0.35%)hashbrown::raw::RawTable<T,A>::find (1 samples, 0.35%)hashbrown::raw::RawTableInner::find_inner (1 samples, 0.35%)hashbrown::raw::sse2::Group::match_byte (1 samples, 0.35%)core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.35%)s4lib::readers::linereader::LineReader::check_store (1 samples, 0.35%)alloc::collections::btree::map::BTreeMap<K,V,A>::contains_key (1 samples, 0.35%)alloc::collections::btree::map::BTreeMap<K,V,A>::get (1 samples, 0.35%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (1 samples, 0.35%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (1 samples, 0.35%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (1 samples, 0.35%)s4lib::data::line::Line::fileoffset_end (1 samples, 0.35%)lru::LruCache<K,V,S>::replace_or_create_node (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::remove (1 samples, 0.35%)hashbrown::map::HashMap<K,V,S,A>::remove_entry (1 samples, 0.35%)hashbrown::map::make_hash (1 samples, 0.35%)<lru::KeyRef<K> as core::hash::Hash>::hash (1 samples, 0.35%)core::hash::impls::<impl core::hash::Hash for u64>::hash (1 samples, 0.35%)<ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (1 samples, 0.35%)ahash::fallback_hash::AHasher::update (1 samples, 0.35%)lru::LruCache<K,V,S>::put (2 samples, 0.70%)lru::LruCache<K,V,S>::capturing_put (2 samples, 0.70%)hashbrown::map::HashMap<K,V,S,A>::insert (1 samples, 0.35%)hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot (1 samples, 0.35%)hashbrown::raw::RawTableInner::find_or_find_insert_slot_inner (1 samples, 0.35%)hashbrown::raw::RawTableInner::fix_insert_slot (1 samples, 0.35%)core::option::Option<T>::as_ref (1 samples, 0.35%)alloc::collections::btree::map::BTreeMap<K,V,A>::contains_key (2 samples, 0.70%)alloc::collections::btree::map::BTreeMap<K,V,A>::get (2 samples, 0.70%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (1 samples, 0.35%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (1 samples, 0.35%)alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::find_sysline_between_datetime_filters (29 samples, 10.21%)s4lib::readers:..s4lib::readers::syslinereader::SyslineReader::find_sysline_between_datetime_filters (29 samples, 10.21%)s4lib::readers:..s4lib::readers::syslinereader::SyslineReader::find_sysline_at_datetime_filter_binary_search (29 samples, 10.21%)s4lib::readers:..s4lib::readers::syslinereader::SyslineReader::find_sysline (29 samples, 10.21%)s4lib::readers:..s4lib::readers::syslinereader::SyslineReader::find_sysline_year (29 samples, 10.21%)s4lib::readers:..s4lib::readers::linereader::LineReader::find_line (8 samples, 2.82%)s4..s4lib::readers::linereader::LineReader::drop_lines (1 samples, 0.35%)s4lib::readers::linereader::LineReader::drop_line (1 samples, 0.35%)alloc::sync::Arc<T>::try_unwrap (2 samples, 0.70%)core::ptr::drop_in_place<alloc::sync::Weak<s4lib::data::sysline::Sysline>> (2 samples, 0.70%)<alloc::sync::Weak<T> as core::ops::drop::Drop>::drop (2 samples, 0.70%)s4lib::readers::syslinereader::SyslineReader::drop_sysline (4 samples, 1.41%)alloc::collections::btree::map::BTreeMap<K,V,A>::remove (1 samples, 0.35%)alloc::collections::btree::map::BTreeMap<K,V,A>::remove_entry (1 samples, 0.35%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (1 samples, 0.35%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (1 samples, 0.35%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (1 samples, 0.35%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (1 samples, 0.35%)alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child_edge (1 samples, 0.35%)alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child (1 samples, 0.35%)alloc::collections::btree::node::BalancingContext<K,V>::do_merge (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::drop_data_try (5 samples, 1.76%)s4lib::readers::syslogprocessor::SyslogProcessor::drop_data (5 samples, 1.76%)s4lib::readers::syslinereader::SyslineReader::drop_data (5 samples, 1.76%)<core::iter::adapters::filter::Filter<I,P> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::iter::traits::iterator::Iterator::find (1 samples, 0.35%)core::iter::traits::iterator::Iterator::try_fold (1 samples, 0.35%)core::iter::traits::iterator::Iterator::find::check::{{closure}} (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::drop_data::{{closure}} (1 samples, 0.35%)__clone3 (94 samples, 33.10%)__clone3start_thread (94 samples, 33.10%)start_threadstd::sys::unix::thread::Thread::new::thread_start (94 samples, 33.10%)std::sys::unix::thread::Thread::new::thread_start<alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (94 samples, 33.10%)<alloc::boxed::Box<F,A> as core::ops::function::FnOnce..<alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (94 samples, 33.10%)<alloc::boxed::Box<F,A> as core::ops::function::FnOnce..core::ops::function::FnOnce::call_once{{vtable.shim}} (94 samples, 33.10%)core::ops::function::FnOnce::call_once{{vtable.shim}}std::thread::Builder::spawn_unchecked_::{{closure}} (94 samples, 33.10%)std::thread::Builder::spawn_unchecked_::{{closure}}std::panic::catch_unwind (94 samples, 33.10%)std::panic::catch_unwindstd::panicking::try (94 samples, 33.10%)std::panicking::trystd::panicking::try::do_call (94 samples, 33.10%)std::panicking::try::do_call<core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (94 samples, 33.10%)<core::panic::unwind_safe::AssertUnwindSafe<F> as core..std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} (94 samples, 33.10%)std::thread::Builder::spawn_unchecked_::{{closure}}::{..std::sys_common::backtrace::__rust_begin_short_backtrace (94 samples, 33.10%)std::sys_common::backtrace::__rust_begin_short_backtra..s4::processing_loop::{{closure}} (94 samples, 33.10%)s4::processing_loop::{{closure}}s4::exec_fileprocessor_thread (94 samples, 33.10%)s4::exec_fileprocessor_threads4::exec_syslogprocessor (94 samples, 33.10%)s4::exec_syslogprocessor<alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (1 samples, 0.35%)s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.35%)once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize (1 samples, 0.35%)once_cell::imp::initialize_or_wait (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.35%)regex::regex::bytes::Regex::new (1 samples, 0.35%)regex::builders::bytes::RegexBuilder::build (1 samples, 0.35%)regex::builders::Builder::build_one_bytes (1 samples, 0.35%)regex_automata::meta::regex::Builder::build (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.35%)regex_automata::meta::strategy::new (1 samples, 0.35%)regex_automata::meta::strategy::Core::new (1 samples, 0.35%)regex_automata::meta::wrappers::BoundedBacktracker::new (1 samples, 0.35%)regex_automata::meta::wrappers::BoundedBacktrackerEngine::new (1 samples, 0.35%)core::ptr::drop_in_place<regex_automata::nfa::thompson::backtrack::Builder> (1 samples, 0.35%)core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (1 samples, 0.35%)core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::range_trie::RangeTrie>> (1 samples, 0.35%)core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::range_trie::RangeTrie>> (1 samples, 0.35%)core::ptr::drop_in_place<regex_automata::nfa::thompson::range_trie::RangeTrie> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::range_trie::State>> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::range_trie::State>> (1 samples, 0.35%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)arena_for_chunk (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (1 samples, 0.35%)s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.35%)once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize (1 samples, 0.35%)once_cell::imp::initialize_or_wait (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.35%)regex::regex::bytes::Regex::new (1 samples, 0.35%)regex::builders::bytes::RegexBuilder::build (1 samples, 0.35%)regex::builders::Builder::build_one_bytes (1 samples, 0.35%)regex_automata::meta::regex::Builder::build (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.35%)regex_automata::meta::strategy::new (1 samples, 0.35%)regex_automata::meta::strategy::Core::new (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::build (1 samples, 0.35%)regex_automata::nfa::thompson::nfa::Inner::add (1 samples, 0.35%)regex_automata::util::alphabet::ByteClassSet::set_range (1 samples, 0.35%)regex_automata::util::alphabet::ByteSet::add (1 samples, 0.35%)regex_automata::meta::strategy::ReverseInner::new (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_from_hir (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by_key (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by (1 samples, 0.35%)alloc::vec::Vec<T,A>::insert (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 1.06%)core::option::Option<T>::map (3 samples, 1.06%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (3 samples, 1.06%)core::slice::<impl [T]>::binary_search_by_key (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by_key::{{closure}} (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::Ord for u8>::cmp (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (3 samples, 1.06%)alloc::vec::Vec<T,A>::insert (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)core::cmp::max (1 samples, 0.35%)core::cmp::Ord::max (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::compile (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (7 samples, 2.46%)re..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (7 samples, 2.46%)<c..core::option::Option<T>::map (7 samples, 2.46%)co..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (7 samples, 2.46%)co..regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_cap (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_concat (7 samples, 2.46%)re..<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (4 samples, 1.41%)core::option::Option<T>::map (4 samples, 1.41%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (4 samples, 1.41%)core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.35%)core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.35%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)regex_automata::dfa::onepass::InternalBuilder::shuffle_states (1 samples, 0.35%)regex_automata::dfa::remapper::Remapper::remap (1 samples, 0.35%)regex_automata::dfa::remapper::onepass::<impl regex_automata::dfa::remapper::Remappable for regex_automata::dfa::onepass::DFA>::remap (1 samples, 0.35%)regex_automata::dfa::onepass::DFA::remap (1 samples, 0.35%)regex_automata::dfa::remapper::Remapper::remap::{{closure}} (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (1 samples, 0.35%)core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (1 samples, 0.35%)<usize as core::slice::index::SliceIndex<[T]>>::index (1 samples, 0.35%)regex_automata::dfa::onepass::InternalBuilder::add_dfa_state_for_nfa_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)regex_automata::dfa::onepass::InternalBuilder::compile_transition (2 samples, 0.70%)<core::result::Result<T,E> as core::ops::try_trait::Try>::branch (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime (12 samples, 4.23%)s4lib..once_cell::sync::OnceCell<T>::get_or_try_init (12 samples, 4.23%)once_..once_cell::imp::OnceCell<T>::initialize (12 samples, 4.23%)once_..once_cell::imp::initialize_or_wait (12 samples, 4.23%)once_..core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (12 samples, 4.23%)core:..once_cell::imp::OnceCell<T>::initialize::{{closure}} (12 samples, 4.23%)once_..s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (12 samples, 4.23%)s4lib..regex::regex::bytes::Regex::new (12 samples, 4.23%)regex..regex::builders::bytes::RegexBuilder::build (12 samples, 4.23%)regex..regex::builders::Builder::build_one_bytes (12 samples, 4.23%)regex..regex_automata::meta::regex::Builder::build (12 samples, 4.23%)regex..regex_automata::meta::regex::Builder::build_many (12 samples, 4.23%)regex..regex_automata::meta::regex::Builder::build_many_from_hir (12 samples, 4.23%)regex..regex_automata::meta::strategy::new (12 samples, 4.23%)regex..regex_automata::meta::strategy::Core::new (11 samples, 3.87%)rege..regex_automata::meta::wrappers::OnePass::new (4 samples, 1.41%)regex_automata::meta::wrappers::OnePassEngine::new (4 samples, 1.41%)regex_automata::dfa::onepass::Builder::build_from_nfa (4 samples, 1.41%)regex_automata::dfa::onepass::InternalBuilder::build (4 samples, 1.41%)regex_automata::dfa::onepass::InternalBuilder::add_start_state (1 samples, 0.35%)regex_automata::dfa::onepass::InternalBuilder::add_dfa_state_for_nfa_state (1 samples, 0.35%)regex_automata::dfa::onepass::InternalBuilder::add_empty_state (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)regex_syntax::hir::literal::PreferenceTrie::create_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)core::slice::<impl [T]>::binary_search_by_key::{{closure}} (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::Ord for u8>::cmp (1 samples, 0.35%)regex_automata::util::prefilter::prefixes (3 samples, 1.06%)regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (3 samples, 1.06%)regex_syntax::hir::literal::Seq::optimize_by_preference (3 samples, 1.06%)regex_syntax::hir::literal::PreferenceTrie::minimize (3 samples, 1.06%)alloc::vec::Vec<T,A>::retain_mut (3 samples, 1.06%)alloc::vec::Vec<T,A>::retain_mut::process_loop (3 samples, 1.06%)regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (3 samples, 1.06%)regex_syntax::hir::literal::PreferenceTrie::insert (3 samples, 1.06%)core::slice::<impl [T]>::binary_search_by_key (2 samples, 0.70%)core::slice::<impl [T]>::binary_search_by (2 samples, 0.70%)regex_automata::meta::reverse_inner::top_concat (1 samples, 0.35%)core::iter::traits::iterator::Iterator::collect (1 samples, 0.35%)<alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)core::iter::traits::iterator::Iterator::fold (1 samples, 0.35%)core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.35%)regex_automata::meta::reverse_inner::top_concat::{{closure}} (1 samples, 0.35%)regex_automata::meta::reverse_inner::flatten (1 samples, 0.35%)core::iter::traits::iterator::Iterator::collect (1 samples, 0.35%)<alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.35%)core::iter::traits::iterator::Iterator::fold (1 samples, 0.35%)core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.35%)core::iter::traits::iterator::Iterator::for_each::call::{{closure}} (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted::{{closure}} (1 samples, 0.35%)core::ptr::write (1 samples, 0.35%)regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (1 samples, 0.35%)regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.35%)regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.35%)alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.35%)alloc::vec::Vec<T,A>::retain_mut::process_loop (1 samples, 0.35%)regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (1 samples, 0.35%)regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.35%)alloc::vec::Vec<T,A>::insert (1 samples, 0.35%)core::intrinsics::copy (1 samples, 0.35%)__memmove_avx512_unaligned_erms (1 samples, 0.35%)regex_automata::meta::strategy::ReverseInner::new (3 samples, 1.06%)regex_automata::meta::reverse_inner::extract (3 samples, 1.06%)regex_automata::meta::reverse_inner::prefilter (2 samples, 0.70%)regex_syntax::hir::literal::Extractor::extract (1 samples, 0.35%)regex_syntax::hir::literal::Extractor::extract_alternation (1 samples, 0.35%)regex_syntax::hir::literal::Extractor::union (1 samples, 0.35%)regex_syntax::hir::literal::Seq::union (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::map::Utf8BoundedEntry>> (1 samples, 0.35%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)malloc_consolidate (1 samples, 0.35%)unlink_chunk (1 samples, 0.35%)core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::compiler::Utf8State>> (2 samples, 0.70%)core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::compiler::Utf8State>> (2 samples, 0.70%)core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Utf8State> (2 samples, 0.70%)core::ptr::drop_in_place<regex_automata::nfa::thompson::map::Utf8BoundedMap> (2 samples, 0.70%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::map::Utf8BoundedEntry>> (2 samples, 0.70%)<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)core::ptr::drop_in_place<[regex_automata::nfa::thompson::map::Utf8BoundedEntry]> (1 samples, 0.35%)core::ptr::drop_in_place<regex_automata::nfa::thompson::map::Utf8BoundedEntry> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::nfa::Transition>> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::nfa::Transition>> (1 samples, 0.35%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::current_memory (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::builder::State>> (2 samples, 0.70%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.70%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (2 samples, 0.70%)alloc::alloc::dealloc (2 samples, 0.70%)__GI___libc_free (2 samples, 0.70%)_int_free (2 samples, 0.70%)malloc_consolidate (2 samples, 0.70%)core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::State> (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)regex_automata::meta::strategy::Core::new (6 samples, 2.11%)r..core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (6 samples, 2.11%)c..core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::builder::Builder>> (4 samples, 1.41%)core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::builder::Builder>> (4 samples, 1.41%)core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::Builder> (4 samples, 1.41%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::builder::State>> (4 samples, 1.41%)<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.70%)core::ptr::drop_in_place<[regex_automata::nfa::thompson::builder::State]> (2 samples, 0.70%)s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (13 samples, 4.58%)s4lib..s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (13 samples, 4.58%)s4lib..s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (13 samples, 4.58%)s4lib..s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (13 samples, 4.58%)s4lib..s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (13 samples, 4.58%)s4lib..s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (13 samples, 4.58%)s4lib..s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (13 samples, 4.58%)s4lib..s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (13 samples, 4.58%)s4lib..s4lib::data::datetime::bytes_to_regex_to_datetime (13 samples, 4.58%)s4lib..once_cell::sync::OnceCell<T>::get_or_try_init (13 samples, 4.58%)once_..once_cell::imp::OnceCell<T>::initialize (13 samples, 4.58%)once_..once_cell::imp::initialize_or_wait (13 samples, 4.58%)once_..core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (13 samples, 4.58%)core:..once_cell::imp::OnceCell<T>::initialize::{{closure}} (13 samples, 4.58%)once_..s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (13 samples, 4.58%)s4lib..regex::regex::bytes::Regex::new (13 samples, 4.58%)regex..regex::builders::bytes::RegexBuilder::build (13 samples, 4.58%)regex..regex::builders::Builder::build_one_bytes (13 samples, 4.58%)regex..regex_automata::meta::regex::Builder::build (13 samples, 4.58%)regex..regex_automata::meta::regex::Builder::build_many (13 samples, 4.58%)regex..regex_automata::meta::regex::Builder::build_many_from_hir (13 samples, 4.58%)regex..regex_automata::meta::strategy::new (13 samples, 4.58%)regex..alloc::sync::Arc<T>::new (1 samples, 0.35%)alloc::boxed::Box<T>::new (1 samples, 0.35%)alloc::alloc::exchange_malloc (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)malloc_consolidate (1 samples, 0.35%)unlink_chunk (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)std::io::impls::<impl std::io::Write for alloc::vec::Vec<u8,A>>::write_all (3 samples, 1.06%)alloc::vec::Vec<T,A>::extend_from_slice (3 samples, 1.06%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (3 samples, 1.06%)alloc::vec::Vec<T,A>::append_elements (3 samples, 1.06%)core::intrinsics::copy_nonoverlapping (3 samples, 1.06%)__memmove_avx512_unaligned_erms (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)crc::crc64::<impl crc::Crc<u64>>::table_entry (6 samples, 2.11%)c..lzma_rs::decode::xz::validate_block_check (18 samples, 6.34%)lzma_rs:..crc::crc64::<impl crc::Crc<u64>>::checksum (18 samples, 6.34%)crc::crc..crc::crc64::<impl crc::Crc<u64>>::update (18 samples, 6.34%)crc::crc..lzma_rs::decode::rangecoder::RangeDecoder<R>::decode_bit (1 samples, 0.35%)lzma_rs::decode::rangecoder::RangeDecoder<R>::normalize (1 samples, 0.35%)lzma_rs::decode::rangecoder::LenDecoder::decode (2 samples, 0.70%)lzma_rs::decode::rangecoder::BitTree::parse (1 samples, 0.35%)lzma_rs::decode::rangecoder::RangeDecoder<R>::parse_bit_tree (1 samples, 0.35%)lzma_rs::decode::rangecoder::RangeDecoder<R>::decode_bit (1 samples, 0.35%)lzma_rs::decode::rangecoder::BitTree::parse_reverse (1 samples, 0.35%)lzma_rs::decode::rangecoder::RangeDecoder<R>::parse_reverse_bit_tree (1 samples, 0.35%)lzma_rs::decode::lzma::DecoderState::decode_distance (3 samples, 1.06%)lzma_rs::decode::rangecoder::BitTree::parse (2 samples, 0.70%)lzma_rs::decode::rangecoder::RangeDecoder<R>::parse_bit_tree (2 samples, 0.70%)lzma_rs::decode::rangecoder::RangeDecoder<R>::decode_bit (2 samples, 0.70%)lzma_rs::decode::rangecoder::RangeDecoder<R>::normalize (2 samples, 0.70%)byteorder::io::ReadBytesExt::read_u8 (2 samples, 0.70%)std::io::Read::read_exact (2 samples, 0.70%)std::io::default_read_exact (2 samples, 0.70%)<std::io::Take<T> as std::io::Read>::read (2 samples, 0.70%)std::io::impls::<impl std::io::Read for &mut R>::read (2 samples, 0.70%)<lzma_rs::decode::util::CountBufRead<R> as std::io::Read>::read (2 samples, 0.70%)<lzma_rs::decode::util::CountBufRead<R> as std::io::Read>::read (2 samples, 0.70%)<std::io::buffered::bufreader::BufReader<R> as std::io::Read>::read (2 samples, 0.70%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)alloc::vec::Vec<T,A>::push (5 samples, 1.76%)core::ptr::write (5 samples, 1.76%)[[kernel.kallsyms]] (5 samples, 1.76%)[[kernel.kallsyms]] (5 samples, 1.76%)[[kernel.kallsyms]] (5 samples, 1.76%)[[kernel.kallsyms]] (5 samples, 1.76%)[[kernel.kallsyms]] (5 samples, 1.76%)lzma_rs::decode::lzma::DecoderState::process_next (12 samples, 4.23%)lzma_..lzma_rs::decode::lzma::DecoderState::process_next_inner (12 samples, 4.23%)lzma_..<lzma_rs::decode::lzbuffer::LzAccumBuffer<W> as lzma_rs::decode::lzbuffer::LzBuffer<W>>::append_lz (7 samples, 2.46%)<l..lzma_rs::decode::lzma2::Lzma2Decoder::parse_lzma (13 samples, 4.58%)lzma_..lzma_rs::decode::lzma::DecoderState::process (13 samples, 4.58%)lzma_..lzma_rs::decode::lzma::DecoderState::process_mode (13 samples, 4.58%)lzma_..<std::io::Take<T> as std::io::BufRead>::fill_buf (1 samples, 0.35%)std::io::impls::<impl std::io::BufRead for &mut B>::fill_buf (1 samples, 0.35%)<lzma_rs::decode::util::CountBufRead<R> as std::io::BufRead>::fill_buf (1 samples, 0.35%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)lzma_rs::xz_decompress (38 samples, 13.38%)lzma_rs::xz_decompre..lzma_rs::decode::xz::decode_stream (38 samples, 13.38%)lzma_rs::decode::xz:..lzma_rs::decode::xz::read_block (38 samples, 13.38%)lzma_rs::decode::xz:..lzma_rs::decode::xz::decode_filter (17 samples, 5.99%)lzma_rs:..lzma_rs::decode::lzma2::Lzma2Decoder::decompress (17 samples, 5.99%)lzma_rs:..<lzma_rs::decode::lzbuffer::LzAccumBuffer<W> as lzma_rs::decode::lzbuffer::LzBuffer<W>>::finish (4 samples, 1.41%)std::io::impls::<impl std::io::Write for &mut W>::write_all (4 samples, 1.41%)std::io::impls::<impl std::io::Write for alloc::vec::Vec<u8,A>>::write_all (4 samples, 1.41%)alloc::vec::Vec<T,A>::extend_from_slice (4 samples, 1.41%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (4 samples, 1.41%)alloc::vec::Vec<T,A>::append_elements (4 samples, 1.41%)core::intrinsics::copy_nonoverlapping (4 samples, 1.41%)__memmove_avx512_unaligned_erms (4 samples, 1.41%)alloc::vec::Vec<T>::with_capacity (1 samples, 0.35%)alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.35%)alloc::alloc::Global::alloc_impl (1 samples, 0.35%)alloc::alloc::alloc (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)sysmalloc (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)s4::exec_fileprocessor_thread (54 samples, 19.01%)s4::exec_fileprocessor_threads4::exec_syslogprocessor (54 samples, 19.01%)s4::exec_syslogprocessors4lib::readers::syslogprocessor::SyslogProcessor::new (41 samples, 14.44%)s4lib::readers::syslog..s4lib::readers::syslinereader::SyslineReader::new (41 samples, 14.44%)s4lib::readers::syslin..s4lib::readers::linereader::LineReader::new (41 samples, 14.44%)s4lib::readers::linere..s4lib::readers::blockreader::BlockReader::new (41 samples, 14.44%)s4lib::readers::blockr..alloc::vec::Vec<T,A>::extend_from_slice (2 samples, 0.70%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (2 samples, 0.70%)alloc::vec::Vec<T,A>::append_elements (2 samples, 0.70%)core::intrinsics::copy_nonoverlapping (2 samples, 0.70%)__memmove_avx512_unaligned_erms (2 samples, 0.70%)aho_corasick::nfa::noncontiguous::Compiler::fill_failure_transitions (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::NFA::next_link (1 samples, 0.35%)core::option::Option<T>::map_or (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::Compiler::densify (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::NFA::alloc_dense_state (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.35%)<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.35%)alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)_int_realloc (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)regex_automata::util::prefilter::teddy::Teddy::new (3 samples, 1.06%)aho_corasick::dfa::Builder::build (3 samples, 1.06%)aho_corasick::nfa::noncontiguous::Builder::build (3 samples, 1.06%)aho_corasick::nfa::noncontiguous::Compiler::compile (3 samples, 1.06%)aho_corasick::nfa::noncontiguous::Compiler::build_trie (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::NFA::add_transition (1 samples, 0.35%)aho_corasick::util::primitives::<impl core::ops::index::Index<aho_corasick::util::primitives::StateID> for alloc::vec::Vec<T>>::index (1 samples, 0.35%)<alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (1 samples, 0.35%)core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (1 samples, 0.35%)<usize as core::slice::index::SliceIndex<[T]>>::index (1 samples, 0.35%)regex_automata::meta::strategy::new (4 samples, 1.41%)regex_automata::meta::strategy::ReverseInner::new (4 samples, 1.41%)regex_automata::meta::reverse_inner::extract (4 samples, 1.41%)regex_automata::meta::reverse_inner::prefilter (4 samples, 1.41%)core::option::Option<T>::and_then (4 samples, 1.41%)regex_automata::meta::reverse_inner::prefilter::{{closure}} (4 samples, 1.41%)regex_automata::util::prefilter::Prefilter::new (4 samples, 1.41%)regex_automata::util::prefilter::Choice::new (4 samples, 1.41%)regex_automata::util::prefilter::aho_corasick::AhoCorasick::new (1 samples, 0.35%)aho_corasick::ahocorasick::AhoCorasickBuilder::build (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::Builder::build (1 samples, 0.35%)aho_corasick::nfa::noncontiguous::Compiler::compile (1 samples, 0.35%)aho_corasick::util::prefilter::Builder::build (1 samples, 0.35%)aho_corasick::util::prefilter::RareBytesBuilder::build (1 samples, 0.35%)aho_corasick::util::prefilter::RareBytesBuilder::build::imp (1 samples, 0.35%)aho_corasick::util::alphabet::ByteSet::contains (1 samples, 0.35%)aho_corasick::util::alphabet::ByteClasses::get (2 samples, 0.70%)regex_automata::meta::strategy::ReverseInner::new (4 samples, 1.41%)regex_automata::meta::reverse_inner::extract (4 samples, 1.41%)regex_automata::meta::reverse_inner::prefilter (4 samples, 1.41%)core::option::Option<T>::and_then (4 samples, 1.41%)regex_automata::meta::reverse_inner::prefilter::{{closure}} (4 samples, 1.41%)regex_automata::util::prefilter::Prefilter::new (4 samples, 1.41%)regex_automata::util::prefilter::Choice::new (4 samples, 1.41%)regex_automata::util::prefilter::teddy::Teddy::new (4 samples, 1.41%)aho_corasick::dfa::Builder::build (4 samples, 1.41%)aho_corasick::dfa::Builder::build_from_noncontiguous (4 samples, 1.41%)aho_corasick::dfa::Builder::finish_build_one_start (4 samples, 1.41%)aho_corasick::dfa::sparse_iter (4 samples, 1.41%)aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (2 samples, 0.70%)aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (2 samples, 0.70%)core::ptr::write (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)[[kernel.kallsyms]] (4 samples, 1.41%)core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.35%)<core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.35%)core::cmp::impls::<impl core::cmp::PartialOrd for usize>::lt (1 samples, 0.35%)<regex_automata::util::primitives::StateID as core::clone::Clone>::clone (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Utf8Compiler::new (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Utf8State::clear (7 samples, 2.46%)re..regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (7 samples, 2.46%)re..alloc::vec::from_elem (7 samples, 2.46%)al..<T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (7 samples, 2.46%)<T..alloc::vec::Vec<T,A>::extend_with (7 samples, 2.46%)al..<alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (2 samples, 0.70%)<regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (2 samples, 0.70%)<alloc::vec::Vec<T,A> as core::clone::Clone>::clone (1 samples, 0.35%)alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.35%)alloc::slice::hack::to_vec (1 samples, 0.35%)<T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.35%)core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (1 samples, 0.35%)core::intrinsics::copy_nonoverlapping (1 samples, 0.35%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (2 samples, 0.70%)core::ptr::write (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)[[kernel.kallsyms]] (3 samples, 1.06%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.23%)<core..core::option::Option<T>::map (12 samples, 4.23%)core:..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.23%)core:..regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 4.23%)regex..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 4.23%)<core..core::option::Option<T>::map (12 samples, 4.23%)core:..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 4.23%)core:..regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 4.23%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_concat (5 samples, 1.76%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (5 samples, 1.76%)core::option::Option<T>::map (5 samples, 1.76%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (5 samples, 1.76%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (5 samples, 1.76%)regex_automata::nfa::thompson::compiler::Compiler::c (5 samples, 1.76%)regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (5 samples, 1.76%)regex_automata::nfa::thompson::compiler::Utf8Compiler::new (5 samples, 1.76%)regex_automata::nfa::thompson::compiler::Utf8State::clear (5 samples, 1.76%)regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (5 samples, 1.76%)alloc::vec::from_elem (5 samples, 1.76%)<T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (5 samples, 1.76%)alloc::vec::Vec<T,A>::extend_with (5 samples, 1.76%)<alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (2 samples, 0.70%)<regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (2 samples, 0.70%)<alloc::vec::Vec<T,A> as core::clone::Clone>::clone (2 samples, 0.70%)alloc::slice::<impl [T]>::to_vec_in (2 samples, 0.70%)alloc::slice::hack::to_vec (2 samples, 0.70%)<T as alloc::slice::hack::ConvertVec>::to_vec (2 samples, 0.70%)core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (2 samples, 0.70%)core::intrinsics::copy_nonoverlapping (2 samples, 0.70%)__memmove_avx512_unaligned_erms (2 samples, 0.70%)regex_automata::meta::regex::Builder::build (17 samples, 5.99%)regex_au..regex_automata::meta::regex::Builder::build_many (17 samples, 5.99%)regex_au..regex_automata::meta::regex::Builder::build_many_from_hir (17 samples, 5.99%)regex_au..regex_automata::meta::strategy::new (17 samples, 5.99%)regex_au..regex_automata::meta::strategy::Core::new (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::compile (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (13 samples, 4.58%)regex..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (13 samples, 4.58%)<core..core::option::Option<T>::map (13 samples, 4.58%)core:..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (13 samples, 4.58%)core:..regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_cap (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_concat (13 samples, 4.58%)regex..<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_repetition (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_zero_or_one (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::add_empty (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add_empty (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::check_size_limit (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::insert (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)_int_realloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)regex::regex::bytes::Regex::new (2 samples, 0.70%)regex::builders::bytes::RegexBuilder::build (2 samples, 0.70%)regex::builders::Builder::build_one_bytes (2 samples, 0.70%)regex_automata::meta::regex::Builder::build (2 samples, 0.70%)regex_automata::meta::regex::Builder::build_many (2 samples, 0.70%)regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.70%)regex_automata::meta::strategy::new (2 samples, 0.70%)regex_automata::meta::strategy::Core::new (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.70%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.70%)core::option::Option<T>::map (2 samples, 0.70%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.70%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.70%)core::option::Option<T>::map (2 samples, 0.70%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_bounded (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_exactly (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::add_sparse (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add_sparse (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.35%)sysmalloc (1 samples, 0.35%)grow_heap (1 samples, 0.35%)__GI___mprotect (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)alloc::vec::Vec<T,A>::with_capacity_in (2 samples, 0.70%)alloc::raw_vec::RawVec<T,A>::with_capacity_in (2 samples, 0.70%)alloc::raw_vec::RawVec<T,A>::allocate_in (2 samples, 0.70%)<alloc::alloc::Global as core::alloc::Allocator>::allocate (2 samples, 0.70%)alloc::alloc::Global::alloc_impl (2 samples, 0.70%)alloc::alloc::alloc (2 samples, 0.70%)__GI___libc_malloc (2 samples, 0.70%)_int_malloc (2 samples, 0.70%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (2 samples, 0.70%)[[kernel.kallsyms]] (3 samples, 1.06%)core::ptr::write (5 samples, 1.76%)<regex_automata::util::primitives::StateID as core::clone::Clone>::clone (1 samples, 0.35%)__memmove_avx512_unaligned_erms (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (11 samples, 3.87%)rege..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (11 samples, 3.87%)<cor..core::option::Option<T>::map (11 samples, 3.87%)core..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (11 samples, 3.87%)core..regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (11 samples, 3.87%)rege..regex_automata::nfa::thompson::compiler::Compiler::c (11 samples, 3.87%)rege..regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (11 samples, 3.87%)rege..regex_automata::nfa::thompson::compiler::Utf8Compiler::new (11 samples, 3.87%)rege..regex_automata::nfa::thompson::compiler::Utf8State::clear (11 samples, 3.87%)rege..regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (11 samples, 3.87%)rege..alloc::vec::from_elem (11 samples, 3.87%)allo..<T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (11 samples, 3.87%)<T a..alloc::vec::Vec<T,A>::extend_with (9 samples, 3.17%)all..<alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (4 samples, 1.41%)<regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (4 samples, 1.41%)<alloc::vec::Vec<T,A> as core::clone::Clone>::clone (3 samples, 1.06%)alloc::slice::<impl [T]>::to_vec_in (3 samples, 1.06%)alloc::slice::hack::to_vec (3 samples, 1.06%)<T as alloc::slice::hack::ConvertVec>::to_vec (3 samples, 1.06%)core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (3 samples, 1.06%)core::intrinsics::copy_nonoverlapping (3 samples, 1.06%)regex_syntax::utf8::Utf8Sequence::as_slice (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (13 samples, 4.58%)<core..core::option::Option<T>::map (13 samples, 4.58%)core:..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (13 samples, 4.58%)core:..regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_cap (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c (13 samples, 4.58%)regex..regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.70%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.70%)core::option::Option<T>::map (2 samples, 0.70%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Utf8Compiler::finish (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Utf8Compiler::compile_from (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Utf8Compiler::pop_freeze (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Utf8Node::set_last_transition (1 samples, 0.35%)core::option::Option<T>::take (1 samples, 0.35%)core::mem::replace (1 samples, 0.35%)core::ptr::read (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add_union (1 samples, 0.35%)regex::builders::Builder::build_one_bytes (15 samples, 5.28%)regex:..regex_automata::meta::regex::Builder::build (15 samples, 5.28%)regex_..regex_automata::meta::regex::Builder::build_many (15 samples, 5.28%)regex_..regex_automata::meta::regex::Builder::build_many_from_hir (15 samples, 5.28%)regex_..regex_automata::meta::strategy::new (15 samples, 5.28%)regex_..regex_automata::meta::strategy::Core::new (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::compile (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (15 samples, 5.28%)regex_..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (15 samples, 5.28%)<core:..core::option::Option<T>::map (15 samples, 5.28%)core::..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (15 samples, 5.28%)core::..regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::c_cap (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::c (15 samples, 5.28%)regex_..regex_automata::nfa::thompson::compiler::Compiler::c_concat (15 samples, 5.28%)regex_..<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.70%)core::option::Option<T>::map (2 samples, 0.70%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.70%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.70%)core::option::Option<T>::map (2 samples, 0.70%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.70%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (2 samples, 0.70%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)core::result::Result<T,E>::map_err (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (2 samples, 0.70%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 1.06%)core::option::Option<T>::map (3 samples, 1.06%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.35%)alloc::alloc::Global::grow_impl (1 samples, 0.35%)alloc::alloc::realloc (1 samples, 0.35%)__GI___libc_realloc (1 samples, 0.35%)_int_realloc (1 samples, 0.35%)__memmove_avx512_unaligned_erms (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)[[kernel.kallsyms]] (1 samples, 0.35%)once_cell::imp::initialize_or_wait (4 samples, 1.41%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (4 samples, 1.41%)once_cell::imp::OnceCell<T>::initialize::{{closure}} (4 samples, 1.41%)s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (4 samples, 1.41%)regex::regex::bytes::Regex::new (4 samples, 1.41%)regex::builders::bytes::RegexBuilder::build (4 samples, 1.41%)regex::builders::Builder::build_one_bytes (4 samples, 1.41%)regex_automata::meta::regex::Builder::build (4 samples, 1.41%)regex_automata::meta::regex::Builder::build_many (4 samples, 1.41%)regex_automata::meta::regex::Builder::build_many_from_hir (4 samples, 1.41%)regex_automata::meta::strategy::new (4 samples, 1.41%)regex_automata::meta::strategy::Core::new (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::compile (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (4 samples, 1.41%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (4 samples, 1.41%)core::option::Option<T>::map (4 samples, 1.41%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (4 samples, 1.41%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.35%)<core::result::Result<T,E> as core::ops::try_trait::Try>::branch (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize (1 samples, 0.35%)once_cell::imp::initialize_or_wait (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.35%)once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.35%)s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.35%)regex::regex::bytes::Regex::new (1 samples, 0.35%)regex::builders::bytes::RegexBuilder::build (1 samples, 0.35%)regex::builders::Builder::build_one_bytes (1 samples, 0.35%)regex_automata::meta::regex::Builder::build (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many (1 samples, 0.35%)regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.35%)regex_automata::meta::strategy::new (1 samples, 0.35%)regex_automata::meta::strategy::Core::new (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.35%)core::option::Option<T>::map (1 samples, 0.35%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (1 samples, 0.35%)alloc::vec::Vec<T,A>::insert (1 samples, 0.35%)alloc::vec::Vec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add_sparse (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (2 samples, 0.70%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)core::result::Result<T,E>::map_err (1 samples, 0.35%)<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 1.06%)core::option::Option<T>::map (3 samples, 1.06%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.35%)regex_automata::nfa::thompson::literal_trie::State::add_match (1 samples, 0.35%)alloc::vec::Vec<T,A>::push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.35%)alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.35%)alloc::raw_vec::finish_grow (1 samples, 0.35%)__GI___libc_malloc (1 samples, 0.35%)_int_malloc (1 samples, 0.35%)regex_automata::nfa::thompson::builder::Builder::add_union (2 samples, 0.70%)regex_automata::nfa::thompson::builder::Builder::add (2 samples, 0.70%)regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 1.06%)regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (3 samples, 1.06%)regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (3 samples, 1.06%)core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::nfa::Transition>> (1 samples, 0.35%)core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::nfa::Transition>> (1 samples, 0.35%)<alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.35%)<alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.35%)alloc::alloc::dealloc (1 samples, 0.35%)__GI___libc_free (1 samples, 0.35%)_int_free (1 samples, 0.35%)all (284 samples, 100%)gen-1000-3-foob (212 samples, 74.65%)gen-1000-3-foob[unknown] (118 samples, 41.55%)[unknown]once_cell::imp::OnceCell<T>::initialize::{{closure}} (7 samples, 2.46%)on..s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (7 samples, 2.46%)s4..regex::regex::bytes::Regex::new (7 samples, 2.46%)re..regex::builders::bytes::RegexBuilder::build (7 samples, 2.46%)re..regex::builders::Builder::build_one_bytes (7 samples, 2.46%)re..regex_automata::meta::regex::Builder::build (7 samples, 2.46%)re..regex_automata::meta::regex::Builder::build_many (7 samples, 2.46%)re..regex_automata::meta::regex::Builder::build_many_from_hir (7 samples, 2.46%)re..regex_automata::meta::strategy::new (7 samples, 2.46%)re..regex_automata::meta::strategy::Core::new (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::compile (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (7 samples, 2.46%)re..<core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (7 samples, 2.46%)<c..core::option::Option<T>::map (7 samples, 2.46%)co..core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (7 samples, 2.46%)co..regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_cap (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c (7 samples, 2.46%)re..regex_automata::nfa::thompson::compiler::Compiler::c_concat (7 samples, 2.46%)re..<core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (4 samples, 1.41%)core::option::Option<T>::map (4 samples, 1.41%)core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (4 samples, 1.41%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_repetition (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_zero_or_one (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_literal (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Compiler::is_reverse (1 samples, 0.35%)regex_automata::nfa::thompson::compiler::Config::get_reverse (1 samples, 0.35%)core::option::Option<T>::unwrap_or (1 samples, 0.35%) \ No newline at end of file diff --git a/releases/0.6.71/flamegraph-syslog.svg b/releases/0.6.71/flamegraph-syslog.svg new file mode 100644 index 00000000..c189a83c --- /dev/null +++ b/releases/0.6.71/flamegraph-syslog.svg @@ -0,0 +1,14477 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 5000; created 20240415T235722-0700
; s4 ./logs/other/tests/gen-99999-1-Motley_Crue.log + + Reset Zoom + Search + + + + check_match (1 samples, 0.04%) + + + + + _dl_start (2 samples, 0.09%) + + + + + _dl_start_final (2 samples, 0.09%) + + + + + _dl_sysdep_start (2 samples, 0.09%) + + + + + dl_main (2 samples, 0.09%) + + + + + _dl_relocate_object (2 samples, 0.09%) + + + + + elf_dynamic_do_Rela (2 samples, 0.09%) + + + + + elf_machine_rela (2 samples, 0.09%) + + + + + _dl_lookup_symbol_x (2 samples, 0.09%) + + + + + do_lookup_x (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::remove_entry (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::remove (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::erase_no_drop (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner<A>::erase (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for &T>::hash (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for usize>::hash (1 samples, 0.04%) + + + + + core::hash::Hasher::write_usize (1 samples, 0.04%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write (1 samples, 0.04%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::write (1 samples, 0.04%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write (1 samples, 0.04%) + + + + + std::collections::hash::set::HashSet<T,S>::remove (3 samples, 0.13%) + + + + + hashbrown::set::HashSet<T,S,A>::remove (3 samples, 0.13%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove (3 samples, 0.13%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove_entry (3 samples, 0.13%) + + + + + hashbrown::map::make_hash (2 samples, 0.09%) + + + + + core::hash::BuildHasher::hash_one (2 samples, 0.09%) + + + + + <std::collections::hash::map::RandomState as core::hash::BuildHasher>::build_hasher (1 samples, 0.04%) + + + + + core::hash::sip::SipHasher13::new_with_keys (1 samples, 0.04%) + + + + + core::hash::sip::Hasher<S>::new_with_keys (1 samples, 0.04%) + + + + + core::hash::sip::Hasher<S>::reset (1 samples, 0.04%) + + + + + std::collections::hash::set::HashSet<T,S>::insert (1 samples, 0.04%) + + + + + hashbrown::set::HashSet<T,S,A>::insert (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::insert (1 samples, 0.04%) + + + + + hashbrown::map::make_insert_hash (1 samples, 0.04%) + + + + + core::hash::BuildHasher::hash_one (1 samples, 0.04%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (1 samples, 0.04%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (1 samples, 0.04%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (1 samples, 0.04%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::c_rounds (1 samples, 0.04%) + + + + + core::num::<impl u64>::rotate_left (1 samples, 0.04%) + + + + + s4lib::readers::helpers::basename (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + std::sys_common::memchr::memrchr (2 samples, 0.09%) + + + + + std::sys::unix::memchr::memrchr (2 samples, 0.09%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (2 samples, 0.09%) + + + + + __memrchr_evex (2 samples, 0.09%) + + + + + __GI___pthread_enable_asynccancel (2 samples, 0.09%) + + + + + __GI___pthread_disable_asynccancel (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (14 samples, 0.60%) + + + + + [[kernel.kallsyms]] (17 samples, 0.73%) + + + + + [[kernel.kallsyms]] (29 samples, 1.24%) + + + + + [[kernel.kallsyms]] (42 samples, 1.80%) + + [.. + + + [[kernel.kallsyms]] (43 samples, 1.84%) + + [.. + + + [[kernel.kallsyms]] (44 samples, 1.89%) + + [.. + + + [[kernel.kallsyms]] (45 samples, 1.93%) + + [.. + + + __GI___libc_write (51 samples, 2.19%) + + _.. + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (52 samples, 2.23%) + + s.. + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (52 samples, 2.23%) + + <.. + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (52 samples, 2.23%) + + <.. + + + std::sys::unix::fd::FileDesc::write (52 samples, 2.23%) + + s.. + + + __GI___libc_write (52 samples, 2.23%) + + _.. + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (9 samples, 0.39%) + + + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (9 samples, 0.39%) + + + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (9 samples, 0.39%) + + + + + std::sys::unix::fd::FileDesc::write (9 samples, 0.39%) + + + + + __GI___libc_write (9 samples, 0.39%) + + + + + __GI___libc_write (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (13 samples, 0.56%) + + + + + [[kernel.kallsyms]] (18 samples, 0.77%) + + + + + [[kernel.kallsyms]] (30 samples, 1.29%) + + + + + [[kernel.kallsyms]] (37 samples, 1.59%) + + + + + [[kernel.kallsyms]] (41 samples, 1.76%) + + + + + [[kernel.kallsyms]] (42 samples, 1.80%) + + [.. + + + [[kernel.kallsyms]] (45 samples, 1.93%) + + [.. + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (56 samples, 2.40%) + + <s.. + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (56 samples, 2.40%) + + <s.. + + + std::sys::unix::fd::FileDesc::write (56 samples, 2.40%) + + st.. + + + __GI___libc_write (47 samples, 2.02%) + + _.. + + + __GI___libc_write (47 samples, 2.02%) + + _.. + + + <std::io::stdio::StdoutLock as std::io::Write>::write (111 samples, 4.76%) + + <std::.. + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (111 samples, 4.76%) + + <std::.. + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (111 samples, 4.76%) + + <std::.. + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (1 samples, 0.04%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (1 samples, 0.04%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + <termcolor::WriterInner<W> as std::io::Write>::write (112 samples, 4.80%) + + <termc.. + + + <std::io::stdio::Stdout as std::io::Write>::write (112 samples, 4.80%) + + <std::.. + + + <&std::io::stdio::Stdout as std::io::Write>::write (112 samples, 4.80%) + + <&std:.. + + + <termcolor::StandardStream as std::io::Write>::write (116 samples, 4.98%) + + <termc.. + + + <termcolor::LossyStandardStream<W> as std::io::Write>::write (116 samples, 4.98%) + + <termc.. + + + std::io::Write::write_all (118 samples, 5.06%) + + std::i.. + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (5 samples, 0.21%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (5 samples, 0.21%) + + + + + <core::ops::range::Range<usize> as core::slice::index::SliceIndex<[T]>>::index (5 samples, 0.21%) + + + + + s4lib::data::line::LinePart::as_slice (20 samples, 0.86%) + + + + + core::sync::atomic::AtomicUsize::store (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_store (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<std::io::stdio::StdoutLock> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<std::sys_common::remutex::ReentrantMutexGuard<core::cell::RefCell<std::io::buffered::linewriter::LineWriter<std::io::stdio::StdoutRaw>>>> (2 samples, 0.09%) + + + + + <std::sys_common::remutex::ReentrantMutexGuard<T> as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + core::cmp::PartialEq::ne (5 samples, 0.21%) + + + + + <termcolor::ColorSpec as core::cmp::PartialEq>::eq (5 samples, 0.21%) + + + + + <core::option::Option<T> as core::cmp::PartialEq>::eq (5 samples, 0.21%) + + + + + <T as core::option::SpecOptionPartialEq>::eq (5 samples, 0.21%) + + + + + core::slice::<impl [T]>::is_empty (1 samples, 0.04%) + + + + + std::io::stdio::Stdout::lock (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<core::cell::RefMut<std::io::buffered::linewriter::LineWriter<std::io::stdio::StdoutRaw>>> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<core::cell::BorrowRefMut> (2 samples, 0.09%) + + + + + <core::cell::BorrowRefMut as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + core::cell::Cell<T>::set (2 samples, 0.09%) + + + + + core::cell::Cell<T>::replace (2 samples, 0.09%) + + + + + core::mem::replace (2 samples, 0.09%) + + + + + core::ptr::write (2 samples, 0.09%) + + + + + core::cell::RefCell<T>::borrow_mut (3 samples, 0.13%) + + + + + core::cell::RefCell<T>::try_borrow_mut (3 samples, 0.13%) + + + + + core::cell::BorrowRefMut::new (3 samples, 0.13%) + + + + + __memrchr_evex (23 samples, 0.99%) + + + + + std::sys_common::memchr::memrchr (29 samples, 1.24%) + + + + + std::sys::unix::memchr::memrchr (29 samples, 1.24%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (29 samples, 1.24%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (30 samples, 1.29%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (30 samples, 1.29%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (1 samples, 0.04%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (1 samples, 0.04%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + termcolor::Ansi<W>::write_str (39 samples, 1.67%) + + + + + std::io::Write::write_all (39 samples, 1.67%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (38 samples, 1.63%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (38 samples, 1.63%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (38 samples, 1.63%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (38 samples, 1.63%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (37 samples, 1.59%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (1 samples, 0.04%) + + + + + <core::ops::range::RangeFrom<usize> as core::slice::index::SliceIndex<[T]>>::index (1 samples, 0.04%) + + + + + core::slice::<impl [T]>::is_empty (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::load (2 samples, 0.09%) + + + + + core::sync::atomic::atomic_load (2 samples, 0.09%) + + + + + std::io::stdio::Stdout::lock (6 samples, 0.26%) + + + + + std::sys_common::remutex::ReentrantMutex<T>::lock (6 samples, 0.26%) + + + + + core::cell::RefCell<T>::borrow_mut (1 samples, 0.04%) + + + + + core::cell::RefCell<T>::try_borrow_mut (1 samples, 0.04%) + + + + + core::cell::BorrowRefMut::new (1 samples, 0.04%) + + + + + std::sys_common::memchr::memrchr (10 samples, 0.43%) + + + + + std::sys::unix::memchr::memrchr (10 samples, 0.43%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (10 samples, 0.43%) + + + + + __memrchr_evex (10 samples, 0.43%) + + + + + __memmove_avx512_unaligned_erms (2 samples, 0.09%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (3 samples, 0.13%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (3 samples, 0.13%) + + + + + core::intrinsics::copy_nonoverlapping (3 samples, 0.13%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (17 samples, 0.73%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (24 samples, 1.03%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (25 samples, 1.07%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (27 samples, 1.16%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (27 samples, 1.16%) + + + + + std::io::Write::write_all (31 samples, 1.33%) + + + + + termcolor::Ansi<W>::write_color (39 samples, 1.67%) + + + + + std::io::stdio::Stdout::lock (1 samples, 0.04%) + + + + + std::sys_common::remutex::ReentrantMutex<T>::lock (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::load (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_load (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<core::cell::RefMut<std::io::buffered::linewriter::LineWriter<std::io::stdio::StdoutRaw>>> (3 samples, 0.13%) + + + + + core::ptr::drop_in_place<core::cell::BorrowRefMut> (3 samples, 0.13%) + + + + + <core::cell::BorrowRefMut as core::ops::drop::Drop>::drop (3 samples, 0.13%) + + + + + core::cell::Cell<T>::set (3 samples, 0.13%) + + + + + core::cell::Cell<T>::replace (3 samples, 0.13%) + + + + + core::mem::replace (3 samples, 0.13%) + + + + + core::ptr::write (3 samples, 0.13%) + + + + + std::sys_common::memchr::memrchr (2 samples, 0.09%) + + + + + std::sys::unix::memchr::memrchr (2 samples, 0.09%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (2 samples, 0.09%) + + + + + __memrchr_evex (2 samples, 0.09%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (7 samples, 0.30%) + + + + + core::intrinsics::copy_nonoverlapping (7 samples, 0.30%) + + + + + __memmove_avx512_unaligned_erms (7 samples, 0.30%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (11 samples, 0.47%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (11 samples, 0.47%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (9 samples, 0.39%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::spare_capacity (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::capacity (2 samples, 0.09%) + + + + + alloc::raw_vec::RawVec<T,A>::capacity (2 samples, 0.09%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (22 samples, 0.94%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (25 samples, 1.07%) + + + + + std::io::Write::write_all (26 samples, 1.12%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (26 samples, 1.12%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (26 samples, 1.12%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (26 samples, 1.12%) + + + + + core::slice::<impl [T]>::is_empty (2 samples, 0.09%) + + + + + std::io::stdio::Stdout::lock (4 samples, 0.17%) + + + + + std::sys_common::remutex::ReentrantMutex<T>::lock (4 samples, 0.17%) + + + + + core::ptr::drop_in_place<core::cell::RefMut<std::io::buffered::linewriter::LineWriter<std::io::stdio::StdoutRaw>>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<core::cell::BorrowRefMut> (1 samples, 0.04%) + + + + + <core::cell::BorrowRefMut as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::cell::Cell<T>::set (1 samples, 0.04%) + + + + + core::cell::Cell<T>::replace (1 samples, 0.04%) + + + + + core::mem::replace (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + core::cell::RefCell<T>::borrow_mut (1 samples, 0.04%) + + + + + core::cell::RefCell<T>::try_borrow_mut (1 samples, 0.04%) + + + + + core::cell::BorrowRefMut::new (1 samples, 0.04%) + + + + + std::sys_common::memchr::memrchr (5 samples, 0.21%) + + + + + std::sys::unix::memchr::memrchr (5 samples, 0.21%) + + + + + std::sys::unix::memchr::memrchr::memrchr_specific (5 samples, 0.21%) + + + + + __memrchr_evex (5 samples, 0.21%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (1 samples, 0.04%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (7 samples, 0.30%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (7 samples, 0.30%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (2 samples, 0.09%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::spare_capacity (1 samples, 0.04%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (12 samples, 0.51%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (22 samples, 0.94%) + + + + + <std::io::stdio::Stdout as std::io::Write>::write (29 samples, 1.24%) + + + + + <termcolor::Ansi<W> as std::io::Write>::write (32 samples, 1.37%) + + + + + <termcolor::IoStandardStream as std::io::Write>::write (32 samples, 1.37%) + + + + + <termcolor::Ansi<W> as termcolor::WriteColor>::reset (36 samples, 1.54%) + + + + + termcolor::Ansi<W>::write_str (36 samples, 1.54%) + + + + + std::io::Write::write_all (36 samples, 1.54%) + + + + + <termcolor::StandardStream as termcolor::WriteColor>::set_color (143 samples, 6.13%) + + <termcol.. + + + <termcolor::LossyStandardStream<W> as termcolor::WriteColor>::set_color (143 samples, 6.13%) + + <termcol.. + + + <termcolor::WriterInner<W> as termcolor::WriteColor>::set_color (143 samples, 6.13%) + + <termcol.. + + + <termcolor::Ansi<W> as termcolor::WriteColor>::set_color (143 samples, 6.13%) + + <termcol.. + + + __GI___pthread_enable_asynccancel (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (13 samples, 0.56%) + + + + + [[kernel.kallsyms]] (20 samples, 0.86%) + + + + + [[kernel.kallsyms]] (30 samples, 1.29%) + + + + + [[kernel.kallsyms]] (38 samples, 1.63%) + + + + + [[kernel.kallsyms]] (42 samples, 1.80%) + + [.. + + + [[kernel.kallsyms]] (45 samples, 1.93%) + + [.. + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::flush (47 samples, 2.02%) + + <.. + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::flush (47 samples, 2.02%) + + <.. + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (47 samples, 2.02%) + + s.. + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (47 samples, 2.02%) + + <.. + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (47 samples, 2.02%) + + <.. + + + std::sys::unix::fd::FileDesc::write (47 samples, 2.02%) + + s.. + + + __GI___libc_write (47 samples, 2.02%) + + _.. + + + __GI___libc_write (47 samples, 2.02%) + + _.. + + + [[kernel.kallsyms]] (46 samples, 1.97%) + + [.. + + + <&std::io::stdio::Stdout as std::io::Write>::flush (48 samples, 2.06%) + + <.. + + + <std::io::stdio::StdoutLock as std::io::Write>::flush (48 samples, 2.06%) + + <.. + + + <termcolor::StandardStream as std::io::Write>::flush (49 samples, 2.10%) + + <.. + + + <std::io::stdio::Stdout as std::io::Write>::flush (49 samples, 2.10%) + + <.. + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (11 samples, 0.47%) + + + + + s4lib::printer::printers::PrinterLogMessage::print_sysline (359 samples, 15.40%) + + s4lib::printer::printers.. + + + s4lib::printer::printers::PrinterLogMessage::print_sysline_color (359 samples, 15.40%) + + s4lib::printer::printers.. + + + std::collections::hash::map::HashMap<K,V,S>::clear (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::clear (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::clear (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<hashbrown::scopeguard::ScopeGuard<&mut hashbrown::raw::RawTable<(usize,usize)>,hashbrown::raw::RawTable<(usize,usize)>::clear::{{closure}}>> (1 samples, 0.04%) + + + + + <hashbrown::scopeguard::ScopeGuard<T,F> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::clear::{{closure}} (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::clear_no_drop (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner<A>::clear_no_drop (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::write_bytes (1 samples, 0.04%) + + + + + core::intrinsics::write_bytes (1 samples, 0.04%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.04%) + + + + + crossbeam_channel::flavors::array::Channel<T>::read (2 samples, 0.09%) + + + + + crossbeam_channel::waker::SyncWaker::notify (2 samples, 0.09%) + + + + + crossbeam_channel::waker::Waker::try_select (2 samples, 0.09%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::position (2 samples, 0.09%) + + + + + crossbeam_channel::waker::Waker::try_select::{{closure}} (2 samples, 0.09%) + + + + + crossbeam_channel::context::Context::unpark (2 samples, 0.09%) + + + + + std::thread::Thread::unpark (2 samples, 0.09%) + + + + + std::sys_common::thread_parker::futex::Parker::unpark (2 samples, 0.09%) + + + + + std::sys::unix::futex::futex_wake (2 samples, 0.09%) + + + + + syscall (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + __memmove_avx512_unaligned_erms (16 samples, 0.69%) + + + + + crossbeam_channel::channel::read (19 samples, 0.82%) + + + + + core::result::Result<T,E>::map_err (10 samples, 0.43%) + + + + + crossbeam_channel::select::SelectedOperation::recv (36 samples, 1.54%) + + + + + crossbeam_channel::utils::shuffle (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (5 samples, 0.21%) + + + + + [[kernel.kallsyms]] (8 samples, 0.34%) + + + + + std::sys::unix::futex::futex_wait (9 samples, 0.39%) + + + + + syscall (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + std::thread::park (10 samples, 0.43%) + + + + + std::sys_common::thread_parker::futex::Parker::park (10 samples, 0.43%) + + + + + core::hint::spin_loop (444 samples, 19.05%) + + core::hint::spin_loop + + + core::core_arch::x86::sse2::_mm_pause (444 samples, 19.05%) + + core::core_arch::x86::sse2::_m.. + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (6 samples, 0.26%) + + + + + [[kernel.kallsyms]] (13 samples, 0.56%) + + + + + [[kernel.kallsyms]] (17 samples, 0.73%) + + + + + [[kernel.kallsyms]] (17 samples, 0.73%) + + + + + [[kernel.kallsyms]] (17 samples, 0.73%) + + + + + [[kernel.kallsyms]] (17 samples, 0.73%) + + + + + crossbeam_utils::backoff::Backoff::snooze (464 samples, 19.91%) + + crossbeam_utils::backoff::Backo.. + + + __GI___sched_yield (20 samples, 0.86%) + + + + + core::sync::atomic::AtomicUsize::load (2 samples, 0.09%) + + + + + core::sync::atomic::atomic_load (2 samples, 0.09%) + + + + + <crossbeam_channel::select::Selected as core::convert::From<usize>>::from (12 samples, 0.51%) + + + + + <alloc::sync::Arc<T> as core::ops::deref::Deref>::deref (13 samples, 0.56%) + + + + + alloc::sync::Arc<T>::inner (13 samples, 0.56%) + + + + + core::ptr::non_null::NonNull<T>::as_ref (13 samples, 0.56%) + + + + + crossbeam_channel::context::Context::wait_until (502 samples, 21.54%) + + crossbeam_channel::context::Contex.. + + + std::sys::unix::locks::futex_mutex::Mutex::lock_contended (1 samples, 0.04%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::spin (1 samples, 0.04%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::lock (5 samples, 0.21%) + + + + + std::sync::mutex::Mutex<T>::lock (6 samples, 0.26%) + + + + + std::sync::mutex::MutexGuard<T>::new (1 samples, 0.04%) + + + + + std::sync::poison::Flag::guard (1 samples, 0.04%) + + + + + std::thread::panicking (1 samples, 0.04%) + + + + + std::panicking::panicking (1 samples, 0.04%) + + + + + std::panicking::panic_count::count_is_zero (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::load (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_load (1 samples, 0.04%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::unlock (6 samples, 0.26%) + + + + + core::ptr::drop_in_place<std::sync::mutex::MutexGuard<crossbeam_channel::waker::Waker>> (7 samples, 0.30%) + + + + + <std::sync::mutex::MutexGuard<T> as core::ops::drop::Drop>::drop (7 samples, 0.30%) + + + + + std::sync::poison::Flag::done (1 samples, 0.04%) + + + + + crossbeam_channel::waker::SyncWaker::unregister (15 samples, 0.64%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::unregister (17 samples, 0.73%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::unregister (17 samples, 0.73%) + + + + + core::ptr::drop_in_place<core::option::Option<crossbeam_channel::waker::Entry>> (2 samples, 0.09%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.04%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (1 samples, 0.04%) + + + + + crossbeam_channel::flavors::array::Channel<T>::start_recv (1 samples, 0.04%) + + + + + std::sync::mutex::Mutex<T>::lock (9 samples, 0.39%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::lock (9 samples, 0.39%) + + + + + crossbeam_channel::waker::Waker::register (3 samples, 0.13%) + + + + + crossbeam_channel::waker::Waker::register_with_packet (3 samples, 0.13%) + + + + + <crossbeam_channel::context::Context as core::clone::Clone>::clone (3 samples, 0.13%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (3 samples, 0.13%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (14 samples, 0.60%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::register (14 samples, 0.60%) + + + + + crossbeam_channel::waker::SyncWaker::register (14 samples, 0.60%) + + + + + core::ptr::drop_in_place<std::sync::mutex::MutexGuard<crossbeam_channel::waker::Waker>> (2 samples, 0.09%) + + + + + <std::sync::mutex::MutexGuard<T> as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::unlock (2 samples, 0.09%) + + + + + core::num::<impl usize>::wrapping_add (1 samples, 0.04%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::accept (3 samples, 0.13%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (3 samples, 0.13%) + + + + + crossbeam_channel::flavors::array::Channel<T>::start_recv (3 samples, 0.13%) + + + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::accept (7 samples, 0.30%) + + + + + <core::slice::iter::IterMut<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <core::iter::adapters::take::Take<I> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + crossbeam_channel::select::run_select::{{closure}} (548 samples, 23.51%) + + crossbeam_channel::select::run_select.. + + + crossbeam_channel::context::Context::with::{{closure}} (549 samples, 23.55%) + + crossbeam_channel::context::Context::.. + + + crossbeam_channel::context::Context::with::{{closure}} (552 samples, 23.68%) + + crossbeam_channel::context::Context::w.. + + + crossbeam_channel::context::Context::with (553 samples, 23.72%) + + crossbeam_channel::context::Context::w.. + + + std::thread::local::LocalKey<T>::try_with (553 samples, 23.72%) + + std::thread::local::LocalKey<T>::try_w.. + + + core::sync::atomic::AtomicUsize::load (6 samples, 0.26%) + + + + + core::sync::atomic::atomic_load (6 samples, 0.26%) + + + + + <crossbeam_channel::flavors::array::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (11 samples, 0.47%) + + + + + crossbeam_channel::flavors::array::Channel<T>::start_recv (11 samples, 0.47%) + + + + + crossbeam_channel::select::Select::select (566 samples, 24.28%) + + crossbeam_channel::select::Select::sele.. + + + crossbeam_channel::select::select (566 samples, 24.28%) + + crossbeam_channel::select::select + + + crossbeam_channel::select::run_select (566 samples, 24.28%) + + crossbeam_channel::select::run_select + + + <crossbeam_channel::channel::Receiver<T> as crossbeam_channel::select::SelectHandle>::try_select (12 samples, 0.51%) + + + + + alloc::vec::Vec<T>::with_capacity (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + crossbeam_channel::select::Select::new (3 samples, 0.13%) + + + + + __memmove_avx512_unaligned_erms (5 samples, 0.21%) + + + + + <alloc::collections::btree::map::Iter<K,V> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + s4::processing_loop::recv_many_chan (614 samples, 26.34%) + + s4::processing_loop::recv_many_chan + + + core::ptr::drop_in_place<core::option::Option<(s4lib::data::common::LogMessage,bool)>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<(s4lib::data::common::LogMessage,bool)> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<s4lib::data::common::LogMessage> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<s4lib::data::sysline::Sysline>> (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::fetch_sub (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_sub (1 samples, 0.04%) + + + + + core::option::Option<T>::map (3 samples, 0.13%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove::{{closure}} (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::remove (4 samples, 0.17%) + + + + + alloc::collections::btree::node::slice_remove (4 samples, 0.17%) + + + + + core::ptr::mut_ptr::<impl *mut T>::add (4 samples, 0.17%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (4 samples, 0.17%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (18 samples, 0.77%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (22 samples, 0.94%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove (29 samples, 1.24%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove_entry (26 samples, 1.12%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (26 samples, 1.12%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (26 samples, 1.12%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::iter_mut (1 samples, 0.04%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::insert (6 samples, 0.26%) + + + + + alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (6 samples, 0.26%) + + + + + __memmove_avx512_unaligned_erms (5 samples, 0.21%) + + + + + s4::processing_loop (1,021 samples, 43.80%) + + s4::processing_loop + + + _start (1,024 samples, 43.93%) + + _start + + + __libc_start_main_impl (1,022 samples, 43.84%) + + __libc_start_main_impl + + + __libc_start_call_main (1,022 samples, 43.84%) + + __libc_start_call_main + + + main (1,022 samples, 43.84%) + + main + + + std::rt::lang_start_internal (1,022 samples, 43.84%) + + std::rt::lang_start_internal + + + std::panic::catch_unwind (1,022 samples, 43.84%) + + std::panic::catch_unwind + + + std::panicking::try (1,022 samples, 43.84%) + + std::panicking::try + + + std::panicking::try::do_call (1,022 samples, 43.84%) + + std::panicking::try::do_call + + + std::rt::lang_start_internal::{{closure}} (1,022 samples, 43.84%) + + std::rt::lang_start_internal::{{closure}} + + + std::panic::catch_unwind (1,022 samples, 43.84%) + + std::panic::catch_unwind + + + std::panicking::try (1,022 samples, 43.84%) + + std::panicking::try + + + std::panicking::try::do_call (1,022 samples, 43.84%) + + std::panicking::try::do_call + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once (1,022 samples, 43.84%) + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>.. + + + std::rt::lang_start::{{closure}} (1,022 samples, 43.84%) + + std::rt::lang_start::{{closure}} + + + std::sys_common::backtrace::__rust_begin_short_backtrace (1,022 samples, 43.84%) + + std::sys_common::backtrace::__rust_begin_short_backtrace + + + core::ops::function::FnOnce::call_once (1,022 samples, 43.84%) + + core::ops::function::FnOnce::call_once + + + s4::main (1,022 samples, 43.84%) + + s4::main + + + s4::cli_process_args (1 samples, 0.04%) + + + + + clap_builder::derive::Parser::parse (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::get_matches (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::get_matches_from (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::try_get_matches_from_mut (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::_do_parse (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::_build_self (1 samples, 0.04%) + + + + + clap_builder::builder::command::Command::_check_help_and_version (1 samples, 0.04%) + + + + + clap_builder::mkeymap::MKeyMap::push (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + __clone3 (1 samples, 0.04%) + + + + + start_thread (1 samples, 0.04%) + + + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 0.04%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.04%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1 samples, 0.04%) + + + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1 samples, 0.04%) + + + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1 samples, 0.04%) + + + + + std::sys::unix::thread::Thread::set_name (1 samples, 0.04%) + + + + + std::sys::unix::thread::truncate_cstr (1 samples, 0.04%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.04%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.04%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.04%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + tcache_init (1 samples, 0.04%) + + + + + tcache_init (1 samples, 0.04%) + + + + + arena_get2 (1 samples, 0.04%) + + + + + arena_get2 (1 samples, 0.04%) + + + + + _int_new_arena (1 samples, 0.04%) + + + + + new_heap (1 samples, 0.04%) + + + + + alloc_new_heap (1 samples, 0.04%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::flush_buf (1 samples, 0.04%) + + + + + <std::io::stdio::StdoutRaw as std::io::Write>::write (1 samples, 0.04%) + + + + + <std::sys::unix::stdio::Stdout as std::io::Write>::write (1 samples, 0.04%) + + + + + std::sys::unix::fd::FileDesc::write (1 samples, 0.04%) + + + + + __GI___libc_write (1 samples, 0.04%) + + + + + __GI___libc_write (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (1 samples, 0.04%) + + + + + alloc::vec::from_elem (1 samples, 0.04%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + __GI___sched_yield (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [unknown] (16 samples, 0.69%) + + + + + <&std::io::stdio::Stdout as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::stdio::StdoutLock as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::buffered::linewriter::LineWriter<W> as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::buffered::linewritershim::LineWriterShim<W> as std::io::Write>::write (13 samples, 0.56%) + + + + + <std::io::buffered::bufwriter::BufWriter<W> as std::io::Write>::write (13 samples, 0.56%) + + + + + std::io::buffered::bufwriter::BufWriter<W>::write_to_buffer_unchecked (13 samples, 0.56%) + + + + + core::intrinsics::copy_nonoverlapping (13 samples, 0.56%) + + + + + __GI___libc_write (13 samples, 0.56%) + + + + + __GI___libc_write (13 samples, 0.56%) + + + + + [[kernel.kallsyms]] (13 samples, 0.56%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (6 samples, 0.26%) + + + + + [[kernel.kallsyms]] (7 samples, 0.30%) + + + + + [[kernel.kallsyms]] (8 samples, 0.34%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (19 samples, 0.82%) + + + + + [[kernel.kallsyms]] (19 samples, 0.82%) + + + + + [[kernel.kallsyms]] (19 samples, 0.82%) + + + + + [[kernel.kallsyms]] (19 samples, 0.82%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + s4 (1,074 samples, 46.07%) + + s4 + + + [[heap]] (9 samples, 0.39%) + + + + + __GI___libc_write (9 samples, 0.39%) + + + + + __GI___libc_write (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + perf-exec (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + regex_automata::meta::wrappers::ReverseHybrid::create_cache (1 samples, 0.04%) + + + + + regex_automata::meta::wrappers::ReverseHybridCache::new (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + regex_automata::meta::wrappers::ReverseHybridCache::new::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::DFA::create_cache (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::Cache::new (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::Lazy::init_cache (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::Lazy::set_all_transitions (1 samples, 0.04%) + + + + + <regex_automata::util::alphabet::ByteClassRepresentatives as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + regex_automata::util::alphabet::Unit::u8 (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + core::ptr::write (2 samples, 0.09%) + + + + + __memset_avx512_unaligned_erms (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + <regex_automata::meta::strategy::ReverseInner as regex_automata::meta::strategy::Strategy>::create_cache (4 samples, 0.17%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::create_cache (3 samples, 0.13%) + + + + + regex_automata::meta::wrappers::PikeVM::create_cache (3 samples, 0.13%) + + + + + regex_automata::meta::wrappers::PikeVMCache::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::PikeVM::create_cache (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::Cache::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::reset (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::SlotTable::reset (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::resize (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::extend_with (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex::regex::bytes::Regex::captures (7 samples, 0.30%) + + + + + regex::regex::bytes::Regex::captures_at (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Regex::captures (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Regex::search_captures (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Regex::search_slots (7 samples, 0.30%) + + + + + regex_automata::util::pool::Pool<T,F>::get (7 samples, 0.30%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::get (7 samples, 0.30%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::get_slow (7 samples, 0.30%) + + + + + <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir::{{closure}} (7 samples, 0.30%) + + + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::create_cache (3 samples, 0.13%) + + + + + regex_automata::meta::wrappers::PikeVM::create_cache (3 samples, 0.13%) + + + + + regex_automata::meta::wrappers::PikeVMCache::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::PikeVM::create_cache (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::Cache::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::ActiveStates::reset (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::pikevm::SlotTable::reset (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::resize (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::extend_with (3 samples, 0.13%) + + + + + core::ptr::write (3 samples, 0.13%) + + + + + __memset_avx512_unaligned_erms (3 samples, 0.13%) + + + + + regex_syntax::ast::visitor::HeapVisitor::pop (1 samples, 0.04%) + + + + + regex_syntax::ast::visitor::HeapVisitor::induct (1 samples, 0.04%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class (1 samples, 0.04%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit_class_post (1 samples, 0.04%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_class_set_item_post (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::TranslatorI::push_char (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_from_slice (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::append_elements (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::TranslatorI::push (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::TranslatorI::pop (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::pop (1 samples, 0.04%) + + + + + core::ptr::read (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init (1 samples, 0.04%) + + + + + regex_syntax::hir::Hir::literal (1 samples, 0.04%) + + + + + <T as core::convert::Into<U>>::into (1 samples, 0.04%) + + + + + alloc::vec::<impl core::convert::From<alloc::vec::Vec<T,A>> for alloc::boxed::Box<[T],A>>::from (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::into_boxed_slice (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::shrink_to_fit (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::shrink_to_fit (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::shrink (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::shrink (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::TranslatorI::pop_concat_expr (3 samples, 0.13%) + + + + + regex_syntax::hir::Hir::class (1 samples, 0.04%) + + + + + regex_syntax::hir::Properties::class (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + regex_syntax::hir::ClassUnicode::try_case_fold_simple (1 samples, 0.04%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::case_fold_simple (1 samples, 0.04%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::canonicalize (1 samples, 0.04%) + + + + + regex_syntax::hir::interval::IntervalSet<I>::is_canonical (1 samples, 0.04%) + + + + + core::cmp::PartialOrd::ge (1 samples, 0.04%) + + + + + <regex_syntax::hir::ClassUnicodeRange as core::cmp::PartialOrd>::partial_cmp (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::TranslatorI::case_fold_char (3 samples, 0.13%) + + + + + regex_syntax::hir::Properties::empty (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + regex_syntax::hir::Hir::into_parts (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (1 samples, 0.04%) + + + + + <regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::option::Option<T>::unwrap (1 samples, 0.04%) + + + + + regex_syntax::hir::Hir::concat (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + regex_syntax::hir::Hir::into_parts (1 samples, 0.04%) + + + + + regex_syntax::hir::Properties::empty (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + regex_syntax::hir::Hir::alternation (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex_syntax::hir::translate::Translator::translate (20 samples, 0.86%) + + + + + regex_syntax::ast::visitor::visit (20 samples, 0.86%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit (20 samples, 0.86%) + + + + + <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_post (17 samples, 0.73%) + + + + + regex_syntax::ast::visitor::visit (3 samples, 0.13%) + + + + + regex_syntax::ast::visitor::HeapVisitor::visit (3 samples, 0.13%) + + + + + regex_syntax::ast::parse::Primitive::into_ast (1 samples, 0.04%) + + + + + regex_syntax::ast::Ast::literal (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::span (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::pos (1 samples, 0.04%) + + + + + core::cell::Cell<T>::get (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_or_add_alternation (1 samples, 0.04%) + + + + + regex_syntax::ast::Concat::into_ast (1 samples, 0.04%) + + + + + regex_syntax::ast::Ast::concat (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_alternate (4 samples, 0.17%) + + + + + regex_syntax::ast::parse::ParserI<P>::pop_group (1 samples, 0.04%) + + + + + regex_syntax::ast::Concat::into_ast (1 samples, 0.04%) + + + + + regex_syntax::ast::Ast::concat (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_set_class_range (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_escape (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::pos (1 samples, 0.04%) + + + + + core::cell::Cell<T>::get (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::maybe_parse_ascii_class (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::char (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::char_at (1 samples, 0.04%) + + + + + core::str::traits::<impl core::ops::index::Index<I> for str>::index (1 samples, 0.04%) + + + + + core::str::traits::<impl core::slice::index::SliceIndex<str> for core::ops::range::RangeFrom<usize>>::index (1 samples, 0.04%) + + + + + core::str::traits::<impl core::slice::index::SliceIndex<str> for core::ops::range::RangeFrom<usize>>::get (1 samples, 0.04%) + + + + + core::str::<impl str>::is_char_boundary (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_set_class (3 samples, 0.13%) + + + + + regex_syntax::ast::ClassSetUnion::push (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + checked_request2size (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::bump (1 samples, 0.04%) + + + + + core::option::Option<T>::unwrap (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_primitive (4 samples, 0.17%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_counted_repetition (1 samples, 0.04%) + + + + + regex_syntax::ast::Ast::repetition (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::ParserI<P>::char (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + checked_request2size (1 samples, 0.04%) + + + + + regex_syntax::ast::parse::Parser::parse (21 samples, 0.90%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse (21 samples, 0.90%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_with_comments (21 samples, 0.90%) + + + + + <core::result::Result<T,E> as core::ops::try_trait::Try>::branch (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::for_each (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::fold (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::hir::Hir>> (2 samples, 0.09%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<[regex_syntax::hir::Hir]> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::Hir> (2 samples, 0.09%) + + + + + <regex_syntax::hir::Hir as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (2 samples, 0.09%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::Repetition>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Repetition> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::Ast>> (1 samples, 0.04%) + + + + + alloc::alloc::box_free (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (4 samples, 0.17%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<regex_syntax::ast::ClassBracketed>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::ClassBracketed> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::ClassSet> (1 samples, 0.04%) + + + + + <regex_syntax::ast::ClassSet as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::pop (1 samples, 0.04%) + + + + + core::ptr::read (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + _int_free (4 samples, 0.17%) + + + + + __GI___libc_free (6 samples, 0.26%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (62 samples, 2.66%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (62 samples, 2.66%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (62 samples, 2.66%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (62 samples, 2.66%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (62 samples, 2.66%) + + s4.. + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (62 samples, 2.66%) + + s4.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime (62 samples, 2.66%) + + s4.. + + + once_cell::sync::OnceCell<T>::get_or_try_init (55 samples, 2.36%) + + o.. + + + once_cell::imp::OnceCell<T>::initialize (55 samples, 2.36%) + + o.. + + + once_cell::imp::initialize_or_wait (55 samples, 2.36%) + + o.. + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (55 samples, 2.36%) + + c.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (55 samples, 2.36%) + + o.. + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (55 samples, 2.36%) + + s.. + + + regex::regex::bytes::Regex::new (55 samples, 2.36%) + + r.. + + + regex::builders::bytes::RegexBuilder::build (55 samples, 2.36%) + + r.. + + + regex::builders::Builder::build_one_bytes (55 samples, 2.36%) + + r.. + + + regex_automata::meta::regex::Builder::build (55 samples, 2.36%) + + r.. + + + regex_automata::meta::regex::Builder::build_many (55 samples, 2.36%) + + r.. + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_syntax::ast::Ast>> (12 samples, 0.51%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (12 samples, 0.51%) + + + + + core::ptr::drop_in_place<[regex_syntax::ast::Ast]> (12 samples, 0.51%) + + + + + core::ptr::drop_in_place<regex_syntax::ast::Ast> (12 samples, 0.51%) + + + + + <regex_syntax::ast::Ast as core::ops::drop::Drop>::drop (12 samples, 0.51%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.04%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (63 samples, 2.70%) + + s4.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (63 samples, 2.70%) + + s4.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_lines (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::find_line_in_block (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::fileoffset_last (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::fileoffset_last (1 samples, 0.04%) + + + + + s4lib::readers::blockreader::BlockReader::fileoffset_last (1 samples, 0.04%) + + + + + s4lib::readers::blockreader::BlockReader::filesz (1 samples, 0.04%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::is_sysline_last (4 samples, 0.17%) + + + + + s4lib::readers::syslinereader::SyslineReader::is_sysline_last (4 samples, 0.17%) + + + + + s4lib::data::sysline::Sysline::fileoffset_end (3 samples, 0.13%) + + + + + s4lib::data::line::Line::fileoffset_end (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::len (3 samples, 0.13%) + + + + + tcache_put (1 samples, 0.04%) + + + + + _int_malloc (7 samples, 0.30%) + + + + + s4lib::data::line::LinePart::block_boxptr_ab (10 samples, 0.43%) + + + + + alloc::boxed::Box<T>::new (10 samples, 0.43%) + + + + + alloc::alloc::exchange_malloc (10 samples, 0.43%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (10 samples, 0.43%) + + + + + alloc::alloc::Global::alloc_impl (10 samples, 0.43%) + + + + + alloc::alloc::alloc (10 samples, 0.43%) + + + + + __GI___libc_malloc (10 samples, 0.43%) + + + + + s4lib::data::line::Line::get_boxptrs (11 samples, 0.47%) + + + + + s4lib::data::line::Line::len (1 samples, 0.04%) + + + + + s4lib::data::datetime::u8_to_str (7 samples, 0.30%) + + + + + core::slice::ascii::<impl [u8]>::is_ascii (7 samples, 0.30%) + + + + + core::slice::ascii::is_ascii (7 samples, 0.30%) + + + + + core::str::<impl str>::contains (1 samples, 0.04%) + + + + + <char as core::str::pattern::Pattern>::is_contained_in (1 samples, 0.04%) + + + + + core::slice::<impl [T]>::contains (1 samples, 0.04%) + + + + + <u8 as core::slice::cmp::SliceContains>::slice_contains (1 samples, 0.04%) + + + + + core::slice::memchr::memchr (1 samples, 0.04%) + + + + + core::slice::memchr::memchr_naive (1 samples, 0.04%) + + + + + s4lib::data::datetime::datetime_from_str_workaround_Issue660 (2 samples, 0.09%) + + + + + <core::str::iter::Chars as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::str::validations::next_code_point (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + chrono::naive::datetime::NaiveDateTime::checked_sub_offset (1 samples, 0.04%) + + + + + chrono::naive::time::NaiveTime::overflowing_sub_offset (1 samples, 0.04%) + + + + + core::num::<impl i32>::div_euclid (1 samples, 0.04%) + + + + + chrono::offset::TimeZone::from_local_datetime::{{closure}} (2 samples, 0.09%) + + + + + <chrono::offset::fixed::FixedOffset as chrono::offset::Offset>::fix (1 samples, 0.04%) + + + + + chrono::offset::LocalResult::Single (3 samples, 0.13%) + + + + + chrono::offset::LocalResult<T>::and_then (7 samples, 0.30%) + + + + + chrono::offset::TimeZone::from_local_datetime (8 samples, 0.34%) + + + + + chrono::offset::LocalResult<T>::earliest (8 samples, 0.34%) + + + + + <chrono::naive::date::NaiveDate as chrono::traits::Datelike>::iso_week (1 samples, 0.04%) + + + + + chrono::naive::isoweek::IsoWeek::from_yof (1 samples, 0.04%) + + + + + chrono::naive::internals::YearFlags::nisoweeks (1 samples, 0.04%) + + + + + chrono::format::parsed::Parsed::to_naive_date::{{closure}} (3 samples, 0.13%) + + + + + chrono::format::parsed::Parsed::to_naive_date (4 samples, 0.17%) + + + + + chrono::format::parsed::Parsed::to_naive_datetime_with_offset (5 samples, 0.21%) + + + + + chrono::format::parsed::Parsed::new (5 samples, 0.21%) + + + + + <chrono::format::parsed::Parsed as core::default::Default>::default (5 samples, 0.21%) + + + + + <core::str::iter::Chars as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::str::validations::next_code_point (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <chrono::format::strftime::StrftimeItems as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + chrono::format::strftime::StrftimeItems::parse_next_item (2 samples, 0.09%) + + + + + chrono::format::parse::parse_internal (63 samples, 2.70%) + + ch.. + + + chrono::format::parse::parse (64 samples, 2.75%) + + ch.. + + + chrono::naive::datetime::NaiveDateTime::parse_from_str (75 samples, 3.22%) + + chr.. + + + s4lib::data::datetime::datetime_parse_from_str (95 samples, 4.08%) + + s4li.. + + + hashbrown::raw::sse2::Group::load (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_loadu_si128 (1 samples, 0.04%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.04%) + + + + + __memcmp_evex_movbe (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::find::{{closure}} (3 samples, 0.13%) + + + + + hashbrown::map::equivalent_key::{{closure}} (3 samples, 0.13%) + + + + + core::str::traits::<impl core::cmp::PartialEq for str>::eq (3 samples, 0.13%) + + + + + core::cmp::impls::<impl core::cmp::PartialEq<&B> for &A>::eq (3 samples, 0.13%) + + + + + core::slice::cmp::<impl core::cmp::PartialEq<[B]> for [A]>::eq (3 samples, 0.13%) + + + + + <[A] as core::slice::cmp::SlicePartialEq<B>>::equal (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::get (6 samples, 0.26%) + + + + + hashbrown::raw::RawTable<T,A>::find (6 samples, 0.26%) + + + + + hashbrown::raw::RawTableInner<A>::find_inner (6 samples, 0.26%) + + + + + core::hash::sip::u8to64_le (11 samples, 0.47%) + + + + + core::cmp::min (3 samples, 0.13%) + + + + + core::cmp::Ord::min (3 samples, 0.13%) + + + + + core::hash::Hasher::write_u8 (22 samples, 0.94%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write (22 samples, 0.94%) + + + + + core::hash::sip::u8to64_le (2 samples, 0.09%) + + + + + core::intrinsics::copy_nonoverlapping (2 samples, 0.09%) + + + + + core::hash::impls::<impl core::hash::Hash for &T>::hash (29 samples, 1.24%) + + + + + core::hash::impls::<impl core::hash::Hash for str>::hash (29 samples, 1.24%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write_str (29 samples, 1.24%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::write_str (29 samples, 1.24%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write_str (29 samples, 1.24%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write (7 samples, 0.30%) + + + + + core::hash::sip::Hasher<S>::reset (1 samples, 0.04%) + + + + + <std::collections::hash::map::RandomState as core::hash::BuildHasher>::build_hasher (5 samples, 0.21%) + + + + + core::hash::sip::SipHasher13::new_with_keys (5 samples, 0.21%) + + + + + core::hash::sip::Hasher<S>::new_with_keys (5 samples, 0.21%) + + + + + core::num::<impl u64>::rotate_left (2 samples, 0.09%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::d_rounds (4 samples, 0.17%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::c_rounds (1 samples, 0.04%) + + + + + core::num::<impl u64>::rotate_left (1 samples, 0.04%) + + + + + hashbrown::map::make_hash (64 samples, 2.75%) + + ha.. + + + core::hash::BuildHasher::hash_one (64 samples, 2.75%) + + co.. + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (30 samples, 1.29%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (30 samples, 1.29%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (30 samples, 1.29%) + + + + + std::collections::hash::map::HashMap<K,V,S>::get (73 samples, 3.13%) + + std.. + + + hashbrown::map::HashMap<K,V,S,A>::get (73 samples, 3.13%) + + has.. + + + hashbrown::map::HashMap<K,V,S,A>::get_inner (73 samples, 3.13%) + + has.. + + + regex_automata::util::captures::GroupInfo::to_index (74 samples, 3.17%) + + reg.. + + + core::slice::<impl [T]>::get (1 samples, 0.04%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::get (1 samples, 0.04%) + + + + + core::num::<impl usize>::checked_add (1 samples, 0.04%) + + + + + core::num::<impl usize>::overflowing_add (1 samples, 0.04%) + + + + + regex_automata::util::captures::Captures::get_group (2 samples, 0.09%) + + + + + <core::option::Option<T> as core::ops::try_trait::Try>::branch (2 samples, 0.09%) + + + + + regex_automata::util::captures::Captures::get_group_by_name (82 samples, 3.52%) + + reg.. + + + regex::regex::bytes::Captures::name (83 samples, 3.56%) + + rege.. + + + core::slice::index::<impl core::ops::index::IndexMut<I> for [T]>::index_mut (1 samples, 0.04%) + + + + + <core::ops::range::Range<usize> as core::slice::index::SliceIndex<[T]>>::index_mut (1 samples, 0.04%) + + + + + core::slice::<impl [T]>::copy_from_slice (2 samples, 0.09%) + + + + + core::intrinsics::copy_nonoverlapping (2 samples, 0.09%) + + + + + __memmove_avx512_unaligned_erms (2 samples, 0.09%) + + + + + s4lib::data::datetime::captures_to_buffer_bytes (87 samples, 3.73%) + + s4li.. + + + alloc::vec::Vec<T,A>::with_capacity_in (3 samples, 0.13%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (3 samples, 0.13%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (3 samples, 0.13%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (3 samples, 0.13%) + + + + + alloc::alloc::Global::alloc_impl (3 samples, 0.13%) + + + + + alloc::alloc::alloc (3 samples, 0.13%) + + + + + __GI___libc_malloc (3 samples, 0.13%) + + + + + tcache_get (3 samples, 0.13%) + + + + + regex_automata::util::captures::Captures::all (4 samples, 0.17%) + + + + + alloc::vec::from_elem (4 samples, 0.17%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + __memset_avx512_unaligned_erms (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Regex::group_info (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::deref::Deref>::deref (1 samples, 0.04%) + + + + + <regex_automata::util::captures::GroupInfo as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::fetch_add (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_add (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Regex::create_captures (7 samples, 0.30%) + + + + + regex_automata::util::captures::Captures::set_pattern (1 samples, 0.04%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::get (1 samples, 0.04%) + + + + + regex_automata::util::pool::inner::Pool<T,F>::guard_owned (1 samples, 0.04%) + + + + + regex_automata::util::pool::Pool<T,F>::get (2 samples, 0.09%) + + + + + regex_automata::meta::regex::RegexInfo::props_union (1 samples, 0.04%) + + + + + regex_automata::meta::regex::RegexInfo::is_impossible (2 samples, 0.09%) + + + + + regex_automata::meta::regex::RegexInfo::is_always_anchored_end (1 samples, 0.04%) + + + + + regex_automata::meta::regex::RegexInfo::props_union (1 samples, 0.04%) + + + + + regex_automata::util::search::Input::anchored (1 samples, 0.04%) + + + + + regex_automata::hybrid::id::LazyStateID::is_tagged (6 samples, 0.26%) + + + + + regex_automata::hybrid::dfa::DFA::next_state_untagged_unchecked (12 samples, 0.51%) + + + + + regex_automata::hybrid::search::find_fwd_imp (21 samples, 0.90%) + + + + + regex_automata::hybrid::dfa::DFA::try_search_fwd (24 samples, 1.03%) + + + + + regex_automata::hybrid::search::find_fwd (24 samples, 1.03%) + + + + + regex_automata::hybrid::regex::Regex::try_search (26 samples, 1.12%) + + + + + regex_automata::meta::wrappers::HybridEngine::try_search (28 samples, 1.20%) + + + + + regex_automata::meta::strategy::Core::try_search_mayfail (30 samples, 1.29%) + + + + + regex_automata::meta::wrappers::Hybrid::get (2 samples, 0.09%) + + + + + core::option::Option<T>::as_ref (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::backtrack::Cache::setup_search (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::backtrack::Visited::setup_search (3 samples, 0.13%) + + + + + __memset_avx512_unaligned_erms (3 samples, 0.13%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::SparseTransitions::matches::{{closure}} (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::nfa::SparseTransitions::matches_byte (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::nfa::SparseTransitions::matches (8 samples, 0.34%) + + + + + core::option::Option<T>::and_then (8 samples, 0.34%) + + + + + regex_automata::util::primitives::<impl core::ops::index::Index<regex_automata::util::primitives::StateID> for [T]>::index (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::nfa::NFA::state (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::nfa::NFA::states (1 samples, 0.04%) + + + + + regex_automata::util::primitives::StateID::as_usize (3 samples, 0.13%) + + + + + regex_automata::util::primitives::SmallIndex::as_usize (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::backtrack::Visited::insert (23 samples, 0.99%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::add (2 samples, 0.09%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::as_mut_ptr (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::ptr (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (5 samples, 0.21%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::step (55 samples, 2.36%) + + r.. + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots_imp (59 samples, 2.53%) + + re.. + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::search_imp (59 samples, 2.53%) + + re.. + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::backtrack (56 samples, 2.40%) + + re.. + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::try_search_slots (68 samples, 2.92%) + + re.. + + + regex_automata::meta::wrappers::BoundedBacktrackerEngine::search_slots (69 samples, 2.96%) + + reg.. + + + core::result::Result<T,E>::unwrap (1 samples, 0.04%) + + + + + regex_automata::util::search::Span::len (1 samples, 0.04%) + + + + + core::num::<impl usize>::saturating_sub (1 samples, 0.04%) + + + + + regex_automata::meta::wrappers::BoundedBacktrackerEngine::max_haystack_len (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::backtrack::BoundedBacktracker::max_haystack_len (4 samples, 0.17%) + + + + + regex_automata::meta::wrappers::BoundedBacktracker::get (9 samples, 0.39%) + + + + + regex_automata::meta::strategy::Core::search_slots_nofail (85 samples, 3.65%) + + rege.. + + + regex_automata::meta::regex::Regex::captures (126 samples, 5.41%) + + regex_a.. + + + regex_automata::meta::regex::Regex::search_captures (126 samples, 5.41%) + + regex_a.. + + + regex_automata::meta::regex::Regex::search_slots (125 samples, 5.36%) + + regex_a.. + + + <regex_automata::meta::strategy::Core as regex_automata::meta::strategy::Strategy>::search_slots (121 samples, 5.19%) + + <regex.. + + + regex::regex::bytes::Regex::captures (134 samples, 5.75%) + + regex::.. + + + regex::regex::bytes::Regex::captures_at (134 samples, 5.75%) + + regex::.. + + + hashbrown::raw::h2 (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::get (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::find (3 samples, 0.13%) + + + + + hashbrown::raw::RawTableInner<A>::find_inner (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::find::{{closure}} (2 samples, 0.09%) + + + + + hashbrown::map::equivalent_key::{{closure}} (2 samples, 0.09%) + + + + + core::str::traits::<impl core::cmp::PartialEq for str>::eq (2 samples, 0.09%) + + + + + core::cmp::impls::<impl core::cmp::PartialEq<&B> for &A>::eq (2 samples, 0.09%) + + + + + core::slice::cmp::<impl core::cmp::PartialEq<[B]> for [A]>::eq (2 samples, 0.09%) + + + + + <[A] as core::slice::cmp::SlicePartialEq<B>>::equal (2 samples, 0.09%) + + + + + __memcmp_evex_movbe (2 samples, 0.09%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write (2 samples, 0.09%) + + + + + core::hash::impls::<impl core::hash::Hash for &T>::hash (3 samples, 0.13%) + + + + + core::hash::impls::<impl core::hash::Hash for str>::hash (3 samples, 0.13%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::write_str (3 samples, 0.13%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::write_str (3 samples, 0.13%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::write_str (3 samples, 0.13%) + + + + + core::hash::Hasher::write_u8 (3 samples, 0.13%) + + + + + core::num::<impl u64>::rotate_left (3 samples, 0.13%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::d_rounds (4 samples, 0.17%) + + + + + <core::hash::sip::Sip13Rounds as core::hash::sip::Sip>::c_rounds (1 samples, 0.04%) + + + + + core::num::<impl u64>::rotate_left (1 samples, 0.04%) + + + + + regex_automata::util::captures::GroupInfo::to_index (13 samples, 0.56%) + + + + + std::collections::hash::map::HashMap<K,V,S>::get (13 samples, 0.56%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get (13 samples, 0.56%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner (13 samples, 0.56%) + + + + + hashbrown::map::make_hash (10 samples, 0.43%) + + + + + core::hash::BuildHasher::hash_one (10 samples, 0.43%) + + + + + <std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish (7 samples, 0.30%) + + + + + <core::hash::sip::SipHasher13 as core::hash::Hasher>::finish (7 samples, 0.30%) + + + + + <core::hash::sip::Hasher<S> as core::hash::Hasher>::finish (7 samples, 0.30%) + + + + + core::num::<impl usize>::checked_add (2 samples, 0.09%) + + + + + core::num::<impl usize>::overflowing_add (2 samples, 0.09%) + + + + + regex_automata::util::captures::Captures::get_group (3 samples, 0.13%) + + + + + regex::regex::bytes::Captures::name (17 samples, 0.73%) + + + + + regex_automata::util::captures::Captures::get_group_by_name (17 samples, 0.73%) + + + + + arena_for_chunk (2 samples, 0.09%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (345 samples, 14.80%) + + s4lib::data::datetime::.. + + + __GI___libc_free (5 samples, 0.21%) + + + + + _int_free (3 samples, 0.13%) + + + + + arena_for_chunk (1 samples, 0.04%) + + + + + arena_for_chunk (1 samples, 0.04%) + + + + + heap_for_ptr (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::boxed::Box<&[u8]>> (2 samples, 0.09%) + + + + + alloc::alloc::box_free (2 samples, 0.09%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (2 samples, 0.09%) + + + + + alloc::alloc::dealloc (2 samples, 0.09%) + + + + + __GI___libc_free (2 samples, 0.09%) + + + + + _int_free (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (369 samples, 15.83%) + + s4lib::readers::sysliner.. + + + s4lib::readers::syslinereader::SyslineReader::dt_first_last_update (1 samples, 0.04%) + + + + + alloc::slice::<impl [T]>::sort_by (1 samples, 0.04%) + + + + + alloc::slice::merge_sort (1 samples, 0.04%) + + + + + _int_malloc (2 samples, 0.09%) + + + + + alloc::vec::Vec<T>::with_capacity (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (4 samples, 0.17%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (4 samples, 0.17%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (4 samples, 0.17%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (4 samples, 0.17%) + + + + + alloc::alloc::Global::alloc_impl (4 samples, 0.17%) + + + + + alloc::alloc::alloc (4 samples, 0.17%) + + + + + __GI___libc_malloc (4 samples, 0.17%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (4 samples, 0.17%) + + + + + alloc::collections::btree::navigate::LazyLeafRange<BorrowType,K,V>::init_front (1 samples, 0.04%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::first_leaf_edge (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::navigate::LazyLeafRange<alloc::collections::btree::node::marker::Immut,K,V>::next_unchecked (7 samples, 0.30%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_unchecked (6 samples, 0.26%) + + + + + alloc::collections::btree::mem::replace (6 samples, 0.26%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_unchecked::{{closure}} (6 samples, 0.26%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_kv (6 samples, 0.26%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,NodeType>,alloc::collections::btree::node::marker::Edge>::right_kv (6 samples, 0.26%) + + + + + <alloc::collections::btree::map::Iter<K,V> as core::iter::traits::iterator::Iterator>::next (8 samples, 0.34%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (18 samples, 0.77%) + + + + + itertools::Itertools::sorted_by (34 samples, 1.46%) + + + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (33 samples, 1.42%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (33 samples, 1.42%) + + + + + alloc::vec::Vec<T>::new (1 samples, 0.04%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::iter (2 samples, 0.09%) + + + + + tcache_put (1 samples, 0.04%) + + + + + _int_free (3 samples, 0.13%) + + + + + __GI___libc_free (4 samples, 0.17%) + + + + + core::result::Result<T,E>::map_err (1 samples, 0.04%) + + + + + tcache_put (2 samples, 0.09%) + + + + + _int_malloc (9 samples, 0.39%) + + + + + __GI___libc_malloc (10 samples, 0.43%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (424 samples, 18.19%) + + s4lib::readers::syslinereade.. + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<&T>>::extend (13 samples, 0.56%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,I>>::spec_extend (13 samples, 0.56%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (13 samples, 0.56%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (13 samples, 0.56%) + + + + + alloc::vec::Vec<T,A>::reserve (13 samples, 0.56%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (13 samples, 0.56%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (13 samples, 0.56%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (13 samples, 0.56%) + + + + + alloc::raw_vec::finish_grow (13 samples, 0.56%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove_entry (1 samples, 0.04%) + + + + + hashbrown::map::make_hash (1 samples, 0.04%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::finish (1 samples, 0.04%) + + + + + ahash::operations::folded_multiply (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::replace_or_create_node (3 samples, 0.13%) + + + + + hashbrown::raw::RawTableInner::set_ctrl_h2 (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::set_ctrl (1 samples, 0.04%) + + + + + core::num::<impl usize>::wrapping_sub (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::record_item_insert_at (2 samples, 0.09%) + + + + + hashbrown::raw::Bucket<T>::as_ptr (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::sub (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::insert_in_slot (4 samples, 0.17%) + + + + + hashbrown::raw::Bucket<T>::write (2 samples, 0.09%) + + + + + core::ptr::mut_ptr::<impl *mut T>::write (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + hashbrown::raw::sse2::Group::match_byte (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::fix_insert_slot (4 samples, 0.17%) + + + + + hashbrown::raw::RawTableInner::is_bucket_full (4 samples, 0.17%) + + + + + hashbrown::raw::is_full (4 samples, 0.17%) + + + + + hashbrown::raw::bitmask::BitMask::remove_lowest_bit (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::insert (11 samples, 0.47%) + + + + + hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot (7 samples, 0.30%) + + + + + hashbrown::raw::RawTableInner::find_or_find_insert_slot_inner (7 samples, 0.30%) + + + + + <hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::is_empty (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::len (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::capturing_put (17 samples, 0.73%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (3 samples, 0.13%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::find (2 samples, 0.09%) + + + + + hashbrown::raw::RawTableInner::find_inner (2 samples, 0.09%) + + + + + lru::LruCache<K,V,S>::put (19 samples, 0.82%) + + + + + lru::LruCache<K,V,S>::detach (4 samples, 0.17%) + + + + + hashbrown::raw::sse2::Group::match_byte (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.04%) + + + + + hashbrown::raw::h2 (4 samples, 0.17%) + + + + + <hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + hashbrown::raw::bitmask::BitMask::lowest_set_bit (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (7 samples, 0.30%) + + + + + hashbrown::raw::RawTable<T,A>::find (7 samples, 0.30%) + + + + + hashbrown::raw::RawTableInner::find_inner (7 samples, 0.30%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (9 samples, 0.39%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (9 samples, 0.39%) + + + + + hashbrown::map::make_hash (2 samples, 0.09%) + + + + + <lru::KeyWrapper<K> as core::hash::Hash>::hash (2 samples, 0.09%) + + + + + core::hash::impls::<impl core::hash::Hash for u64>::hash (2 samples, 0.09%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (2 samples, 0.09%) + + + + + ahash::fallback_hash::AHasher::update (2 samples, 0.09%) + + + + + ahash::operations::folded_multiply (2 samples, 0.09%) + + + + + lru::LruCache<K,V,S>::get (14 samples, 0.60%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (461 samples, 19.78%) + + s4lib::readers::syslinereader::.. + + + s4lib::data::sysline::Sysline::fileoffset_end (2 samples, 0.09%) + + + + + s4lib::data::line::Line::fileoffset_end (2 samples, 0.09%) + + + + + s4lib::data::line::LinePart::len (2 samples, 0.09%) + + + + + core::iter::traits::iterator::Iterator::rev (2 samples, 0.09%) + + + + + core::iter::traits::iterator::Iterator::filter (1 samples, 0.04%) + + + + + core::iter::adapters::filter::Filter<I,P>::new (1 samples, 0.04%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_upper_bound_index (2 samples, 0.09%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (2 samples, 0.09%) + + + + + <rangemap::range_wrapper::RangeStartWrapper<T> as core::cmp::Ord>::cmp (6 samples, 0.26%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (6 samples, 0.26%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_lower_bound_index (10 samples, 0.43%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (10 samples, 0.43%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (3 samples, 0.13%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (3 samples, 0.13%) + + + + + core::ptr::const_ptr::<impl *const T>::read (3 samples, 0.13%) + + + + + core::ptr::read (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (22 samples, 0.94%) + + + + + alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,Type>::keys (1 samples, 0.04%) + + + + + <rangemap::range_wrapper::RangeStartWrapper<T> as core::cmp::Ord>::cmp (3 samples, 0.13%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_upper_bound_edge (16 samples, 0.69%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_upper_bound_index (16 samples, 0.69%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (16 samples, 0.69%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (45 samples, 1.93%) + + a.. + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (6 samples, 0.26%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (6 samples, 0.26%) + + + + + core::ptr::const_ptr::<impl *const T>::read (6 samples, 0.26%) + + + + + core::ptr::read (6 samples, 0.26%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (47 samples, 2.02%) + + a.. + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (53 samples, 2.27%) + + a.. + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::split (2 samples, 0.09%) + + + + + alloc::collections::btree::node::LeafNode<K,V>::new (2 samples, 0.09%) + + + + + alloc::boxed::Box<T,A>::new_uninit_in (2 samples, 0.09%) + + + + + alloc::boxed::Box<T,A>::try_new_uninit_in (2 samples, 0.09%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (2 samples, 0.09%) + + + + + alloc::alloc::Global::alloc_impl (2 samples, 0.09%) + + + + + alloc::alloc::alloc (2 samples, 0.09%) + + + + + __GI___libc_malloc (2 samples, 0.09%) + + + + + _int_malloc (2 samples, 0.09%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_fit (1 samples, 0.04%) + + + + + alloc::collections::btree::node::slice_insert (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::write (1 samples, 0.04%) + + + + + alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (4 samples, 0.17%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (4 samples, 0.17%) + + + + + <rangemap::range_wrapper::RangeStartWrapper<T> as core::cmp::Ord>::cmp (7 samples, 0.30%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (7 samples, 0.30%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + rangemap::map::RangeMap<K,V>::insert (75 samples, 3.22%) + + ran.. + + + alloc::collections::btree::map::BTreeMap<K,V,A>::insert (19 samples, 0.82%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::entry (15 samples, 0.64%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (15 samples, 0.64%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (15 samples, 0.64%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (15 samples, 0.64%) + + + + + alloc::sync::Arc<T>::new (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __rust_alloc (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>::len (1 samples, 0.04%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::split (1 samples, 0.04%) + + + + + alloc::collections::btree::node::LeafNode<K,V>::new (1 samples, 0.04%) + + + + + alloc::boxed::Box<T,A>::new_uninit_in (1 samples, 0.04%) + + + + + alloc::boxed::Box<T,A>::try_new_uninit_in (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + tcache_put (1 samples, 0.04%) + + + + + alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_fit (1 samples, 0.04%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::insert (6 samples, 0.26%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::entry (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (3 samples, 0.13%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::insert_sysline (88 samples, 3.78%) + + s4li.. + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_upper_bound_index (1 samples, 0.04%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (1 samples, 0.04%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <(core::ops::range::Bound<T>,core::ops::range::Bound<T>) as core::ops::range::RangeBounds<T>>::start_bound (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (5 samples, 0.21%) + + + + + alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,Type>::keys (1 samples, 0.04%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_upper_bound_edge (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_upper_bound_index (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (3 samples, 0.13%) + + + + + <rangemap::range_wrapper::RangeStartWrapper<T> as core::cmp::Ord>::cmp (2 samples, 0.09%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (11 samples, 0.47%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (3 samples, 0.13%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (3 samples, 0.13%) + + + + + core::ptr::const_ptr::<impl *const T>::read (3 samples, 0.13%) + + + + + core::ptr::read (3 samples, 0.13%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (17 samples, 0.73%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (26 samples, 1.12%) + + + + + alloc::collections::btree::mem::replace (1 samples, 0.04%) + + + + + alloc::collections::btree::navigate::LeafRange<BorrowType,K,V>::perform_next_back_checked::{{closure}} (1 samples, 0.04%) + + + + + rangemap::map::RangeMap<K,V>::get_key_value (29 samples, 1.24%) + + + + + <alloc::collections::btree::map::Range<K,V> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (3 samples, 0.13%) + + + + + alloc::collections::btree::navigate::LeafRange<alloc::collections::btree::node::marker::Immut,K,V>::next_back_checked (3 samples, 0.13%) + + + + + alloc::collections::btree::navigate::LeafRange<BorrowType,K,V>::perform_next_back_checked (3 samples, 0.13%) + + + + + hashbrown::raw::sse2::Group::match_byte (4 samples, 0.17%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (4 samples, 0.17%) + + + + + hashbrown::raw::h2 (5 samples, 0.21%) + + + + + lru::LruCache<K,V,S>::get (10 samples, 0.43%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (10 samples, 0.43%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (10 samples, 0.43%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (10 samples, 0.43%) + + + + + hashbrown::raw::RawTable<T,A>::find (10 samples, 0.43%) + + + + + hashbrown::raw::RawTableInner::find_inner (10 samples, 0.43%) + + + + + <hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + hashbrown::raw::bitmask::BitMask::remove_lowest_bit (1 samples, 0.04%) + + + + + core::option::Option<T>::as_ref (1 samples, 0.04%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (2 samples, 0.09%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (3 samples, 0.13%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (2 samples, 0.09%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (2 samples, 0.09%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::contains_key (7 samples, 0.30%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::get (7 samples, 0.30%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (6 samples, 0.26%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (1 samples, 0.04%) + + + + + core::ptr::const_ptr::<impl *const T>::read (1 samples, 0.04%) + + + + + core::ptr::read (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::check_store (48 samples, 2.06%) + + s.. + + + alloc::sync::Arc<T>::new (1 samples, 0.04%) + + + + + alloc::boxed::Box<T>::new (1 samples, 0.04%) + + + + + alloc::alloc::exchange_malloc (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::split (5 samples, 0.21%) + + + + + alloc::collections::btree::node::LeafNode<K,V>::new (5 samples, 0.21%) + + + + + alloc::boxed::Box<T,A>::new_uninit_in (5 samples, 0.21%) + + + + + alloc::boxed::Box<T,A>::try_new_uninit_in (5 samples, 0.21%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (5 samples, 0.21%) + + + + + alloc::alloc::Global::alloc_impl (5 samples, 0.21%) + + + + + alloc::alloc::alloc (5 samples, 0.21%) + + + + + __GI___libc_malloc (5 samples, 0.21%) + + + + + _int_malloc (5 samples, 0.21%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert (6 samples, 0.26%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (8 samples, 0.34%) + + + + + alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (14 samples, 0.60%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (5 samples, 0.21%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (13 samples, 0.56%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (13 samples, 0.56%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::insert (28 samples, 1.20%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::entry (14 samples, 0.60%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (14 samples, 0.60%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::insert_line (31 samples, 1.33%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (2 samples, 0.09%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (10 samples, 0.43%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_lower_bound_index (10 samples, 0.43%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (10 samples, 0.43%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (11 samples, 0.47%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (12 samples, 0.51%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (12 samples, 0.51%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (4 samples, 0.17%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::get (7 samples, 0.30%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (7 samples, 0.30%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (7 samples, 0.30%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (7 samples, 0.30%) + + + + + core::sync::atomic::AtomicUsize::fetch_add (2 samples, 0.09%) + + + + + core::sync::atomic::atomic_add (2 samples, 0.09%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (3 samples, 0.13%) + + + + + s4lib::readers::linereader::LineReader::get_linep (23 samples, 0.99%) + + + + + s4lib::readers::linereader::LineReader::file_offset_at_block_offset_index (4 samples, 0.17%) + + + + + s4lib::readers::blockreader::BlockReader::file_offset_at_block_offset_index (4 samples, 0.17%) + + + + + s4lib::readers::blockreader::BlockReader::file_offset_at_block_offset (4 samples, 0.17%) + + + + + lru::LruCache<K,V,S>::detach (4 samples, 0.17%) + + + + + lru::LruCache<K,V,S>::attach (1 samples, 0.04%) + + + + + hashbrown::raw::h2 (2 samples, 0.09%) + + + + + hashbrown::raw::Bucket<T>::as_ref (1 samples, 0.04%) + + + + + hashbrown::raw::Bucket<T>::as_ptr (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::sub (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::find::{{closure}} (2 samples, 0.09%) + + + + + <hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (8 samples, 0.34%) + + + + + hashbrown::raw::RawTable<T,A>::find (8 samples, 0.34%) + + + + + hashbrown::raw::RawTableInner::find_inner (8 samples, 0.34%) + + + + + lru::LruCache<K,V,S>::get (14 samples, 0.60%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (9 samples, 0.39%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (9 samples, 0.39%) + + + + + hashbrown::map::make_hash (1 samples, 0.04%) + + + + + <lru::KeyWrapper<K> as core::hash::Hash>::hash (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for u64>::hash (1 samples, 0.04%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (1 samples, 0.04%) + + + + + ahash::fallback_hash::AHasher::update (1 samples, 0.04%) + + + + + ahash::operations::folded_multiply (1 samples, 0.04%) + + + + + core::num::<impl u128>::wrapping_mul (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::check_store_LRU (15 samples, 0.64%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicUsize::fetch_add (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_add (1 samples, 0.04%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (3 samples, 0.13%) + + + + + <core::iter::adapters::enumerate::Enumerate<I> as core::iter::traits::iterator::Iterator>::next (6 samples, 0.26%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next (6 samples, 0.26%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_lower_bound_index (20 samples, 0.86%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (20 samples, 0.86%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (8 samples, 0.34%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (8 samples, 0.34%) + + + + + core::ptr::const_ptr::<impl *const T>::read (8 samples, 0.34%) + + + + + core::ptr::read (8 samples, 0.34%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree_for_bifurcation (30 samples, 1.29%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::range_search (31 samples, 1.33%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::find_leaf_edges_spanning_range (31 samples, 1.33%) + + + + + alloc::collections::btree::navigate::LeafRange<BorrowType,K,V>::none (1 samples, 0.04%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::range (38 samples, 1.63%) + + + + + alloc::collections::btree::navigate::LeafRange<BorrowType,K,V>::is_empty (1 samples, 0.04%) + + + + + <core::option::Option<T> as core::cmp::PartialEq>::eq (1 samples, 0.04%) + + + + + <T as core::option::SpecOptionPartialEq>::eq (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::get_linep (40 samples, 1.72%) + + + + + <alloc::collections::btree::map::Range<K,V> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::LeafRange<alloc::collections::btree::node::marker::Immut,K,V>::next_checked (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::LeafRange<BorrowType,K,V>::perform_next_checked (2 samples, 0.09%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (4 samples, 0.17%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (5 samples, 0.21%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (5 samples, 0.21%) + + + + + s4lib::readers::linereader::LineReader::check_store (47 samples, 2.02%) + + s.. + + + alloc::collections::btree::map::BTreeMap<K,V,A>::contains_key (7 samples, 0.30%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::get (7 samples, 0.30%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (7 samples, 0.30%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (2 samples, 0.09%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (2 samples, 0.09%) + + + + + core::ptr::const_ptr::<impl *const T>::read (2 samples, 0.09%) + + + + + core::ptr::read (2 samples, 0.09%) + + + + + s4lib::readers::blockreader::BlockReader::filesz (1 samples, 0.04%) + + + + + s4lib::readers::blockreader::BlockReader::count_blocks (1 samples, 0.04%) + + + + + s4lib::readers::linereader::LineReader::blockoffset_last (3 samples, 0.13%) + + + + + s4lib::readers::blockreader::BlockReader::blockoffset_last (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (6 samples, 0.26%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (9 samples, 0.39%) + + + + + [[kernel.kallsyms]] (12 samples, 0.51%) + + + + + std::io::Read::read_to_end (24 samples, 1.03%) + + + + + std::io::default_read_to_end (24 samples, 1.03%) + + + + + <std::io::Take<T> as std::io::Read>::read_buf (24 samples, 1.03%) + + + + + <&std::fs::File as std::io::Read>::read_buf (24 samples, 1.03%) + + + + + std::sys::unix::fs::File::read_buf (24 samples, 1.03%) + + + + + std::sys::unix::fd::FileDesc::read_buf (24 samples, 1.03%) + + + + + __GI___libc_read (24 samples, 1.03%) + + + + + __GI___libc_read (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + [[kernel.kallsyms]] (24 samples, 1.03%) + + + + + grow_heap (1 samples, 0.04%) + + + + + __GI___mprotect (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + s4lib::readers::blockreader::BlockReader::read_block_File (27 samples, 1.16%) + + + + + alloc::vec::Vec<T>::with_capacity (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (3 samples, 0.13%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (3 samples, 0.13%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (3 samples, 0.13%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (3 samples, 0.13%) + + + + + alloc::alloc::Global::alloc_impl (3 samples, 0.13%) + + + + + alloc::alloc::alloc (3 samples, 0.13%) + + + + + __GI___libc_malloc (3 samples, 0.13%) + + + + + _int_malloc (3 samples, 0.13%) + + + + + sysmalloc (3 samples, 0.13%) + + + + + lru::LruCache<K,V,S>::detach (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::get (2 samples, 0.09%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::find (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::find_inner (1 samples, 0.04%) + + + + + s4lib::readers::blockreader::BlockReader::read_block (36 samples, 1.54%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (7 samples, 0.30%) + + + + + s4lib::readers::blockreader::BlockReader::block_offset_at_file_offset (2 samples, 0.09%) + + + + + s4lib::data::line::LinePart::new (5 samples, 0.21%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.04%) + + + + + core::ptr::write (1 samples, 0.04%) + + + + + s4lib::data::line::Line::prepend (3 samples, 0.13%) + + + + + __rust_alloc (3 samples, 0.13%) + + + + + __rdl_alloc (2 samples, 0.09%) + + + + + tcache_get (1 samples, 0.04%) + + + + + checked_request2size (2 samples, 0.09%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + _int_malloc (3 samples, 0.13%) + + + + + tcache_put (2 samples, 0.09%) + + + + + s4lib::data::line::Line::new (17 samples, 0.73%) + + + + + <s4lib::data::line::Line as core::default::Default>::default (17 samples, 0.73%) + + + + + alloc::vec::Vec<T>::with_capacity (17 samples, 0.73%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (17 samples, 0.73%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (17 samples, 0.73%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (17 samples, 0.73%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (17 samples, 0.73%) + + + + + alloc::alloc::Global::alloc_impl (17 samples, 0.73%) + + + + + alloc::alloc::alloc (17 samples, 0.73%) + + + + + __GI___libc_malloc (12 samples, 0.51%) + + + + + <lru::KeyRef<K> as core::hash::Hash>::hash (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for u64>::hash (1 samples, 0.04%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (1 samples, 0.04%) + + + + + ahash::fallback_hash::AHasher::update (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::replace_or_create_node (2 samples, 0.09%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove (2 samples, 0.09%) + + + + + hashbrown::map::HashMap<K,V,S,A>::remove_entry (2 samples, 0.09%) + + + + + hashbrown::map::make_hash (2 samples, 0.09%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::finish (1 samples, 0.04%) + + + + + ahash::operations::folded_multiply (1 samples, 0.04%) + + + + + core::num::<impl u128>::wrapping_mul (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::attach (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::record_item_insert_at (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::bucket (2 samples, 0.09%) + + + + + hashbrown::raw::Bucket<T>::from_base_index (2 samples, 0.09%) + + + + + core::ptr::mut_ptr::<impl *mut T>::sub (2 samples, 0.09%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::insert_in_slot (4 samples, 0.17%) + + + + + hashbrown::raw::Bucket<T>::write (1 samples, 0.04%) + + + + + hashbrown::raw::Bucket<T>::as_ptr (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::sub (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::fix_insert_slot (2 samples, 0.09%) + + + + + hashbrown::raw::RawTableInner::is_bucket_full (2 samples, 0.09%) + + + + + hashbrown::raw::is_full (2 samples, 0.09%) + + + + + hashbrown::raw::RawTableInner::find_or_find_insert_slot_inner (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot::{{closure}} (1 samples, 0.04%) + + + + + hashbrown::map::equivalent_key::{{closure}} (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::insert (8 samples, 0.34%) + + + + + hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot (4 samples, 0.17%) + + + + + hashbrown::raw::RawTable<T,A>::reserve (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::is_empty (3 samples, 0.13%) + + + + + hashbrown::raw::RawTable<T,A>::len (3 samples, 0.13%) + + + + + hashbrown::raw::sse2::Group::match_byte (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.04%) + + + + + hashbrown::raw::h2 (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (4 samples, 0.17%) + + + + + hashbrown::raw::RawTable<T,A>::find (4 samples, 0.17%) + + + + + hashbrown::raw::RawTableInner::find_inner (4 samples, 0.17%) + + + + + hashbrown::raw::RawTable<T,A>::find::{{closure}} (1 samples, 0.04%) + + + + + hashbrown::raw::Bucket<T>::as_ref (1 samples, 0.04%) + + + + + hashbrown::raw::Bucket<T>::as_ptr (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::sub (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (8 samples, 0.34%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (8 samples, 0.34%) + + + + + hashbrown::map::make_hash (1 samples, 0.04%) + + + + + <lru::KeyRef<K> as core::hash::Hash>::hash (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for u64>::hash (1 samples, 0.04%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (1 samples, 0.04%) + + + + + ahash::fallback_hash::AHasher::update (1 samples, 0.04%) + + + + + ahash::operations::folded_multiply (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::capturing_put (20 samples, 0.86%) + + + + + lru::LruCache<K,V,S>::put (26 samples, 1.12%) + + + + + core::ptr::drop_in_place<core::option::Option<s4lib::common::ResultS3<(u64,alloc::sync::Arc<s4lib::data::line::Line>),std::io::error::Error>>> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<s4lib::data::line::Line>> (3 samples, 0.13%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (3 samples, 0.13%) + + + + + core::option::Option<T>::as_ref (1 samples, 0.04%) + + + + + core::cmp::impls::<impl core::cmp::Ord for u64>::cmp (3 samples, 0.13%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::search_node (11 samples, 0.47%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,Type>>::find_key_index (11 samples, 0.47%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,Type>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>::force (1 samples, 0.04%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::contains_key (14 samples, 0.60%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::get (14 samples, 0.60%) + + + + + alloc::collections::btree::search::<impl alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::search_tree (13 samples, 0.56%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Internal>,alloc::collections::btree::node::marker::Edge>::descend (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init_read (1 samples, 0.04%) + + + + + core::ptr::const_ptr::<impl *const T>::read (1 samples, 0.04%) + + + + + core::ptr::read (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (9 samples, 0.39%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (9 samples, 0.39%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index (9 samples, 0.39%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (2 samples, 0.09%) + + + + + s4lib::readers::linereader::LineReader::find_line (288 samples, 12.36%) + + s4lib::readers::li.. + + + __rdl_alloc (1 samples, 0.04%) + + + + + s4lib::data::sysline::Sysline::new_no_lines (2 samples, 0.09%) + + + + + alloc::vec::Vec<T>::with_capacity (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (2 samples, 0.09%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (2 samples, 0.09%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (2 samples, 0.09%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (2 samples, 0.09%) + + + + + alloc::alloc::Global::alloc_impl (2 samples, 0.09%) + + + + + alloc::alloc::alloc (2 samples, 0.09%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + s4lib::common::ResultS3::Found (2 samples, 0.09%) + + + + + hashbrown::raw::RawTable<T,A>::insert_in_slot (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::record_item_insert_at (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::set_ctrl_h2 (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::set_ctrl (1 samples, 0.04%) + + + + + core::num::<impl usize>::wrapping_sub (1 samples, 0.04%) + + + + + hashbrown::raw::h2 (1 samples, 0.04%) + + + + + hashbrown::map::HashMap<K,V,S,A>::insert (7 samples, 0.30%) + + + + + hashbrown::raw::RawTable<T,A>::find_or_find_insert_slot (6 samples, 0.26%) + + + + + hashbrown::raw::RawTableInner::find_or_find_insert_slot_inner (6 samples, 0.26%) + + + + + hashbrown::raw::RawTableInner::fix_insert_slot (5 samples, 0.21%) + + + + + hashbrown::raw::RawTableInner::is_bucket_full (5 samples, 0.21%) + + + + + hashbrown::raw::is_full (5 samples, 0.21%) + + + + + hashbrown::raw::RawTable<T,A>::is_empty (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::len (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::get_mut (1 samples, 0.04%) + + + + + hashbrown::raw::RawTable<T,A>::find (1 samples, 0.04%) + + + + + hashbrown::raw::RawTableInner::find_inner (1 samples, 0.04%) + + + + + hashbrown::raw::sse2::Group::match_byte (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_movemask_epi8 (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::capturing_put (10 samples, 0.43%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_mut (3 samples, 0.13%) + + + + + hashbrown::map::HashMap<K,V,S,A>::get_inner_mut (3 samples, 0.13%) + + + + + hashbrown::map::make_hash (1 samples, 0.04%) + + + + + <lru::KeyRef<K> as core::hash::Hash>::hash (1 samples, 0.04%) + + + + + core::hash::impls::<impl core::hash::Hash for u64>::hash (1 samples, 0.04%) + + + + + <ahash::fallback_hash::AHasher as core::hash::Hasher>::write_u64 (1 samples, 0.04%) + + + + + ahash::fallback_hash::AHasher::update (1 samples, 0.04%) + + + + + ahash::operations::folded_multiply (1 samples, 0.04%) + + + + + lru::LruCache<K,V,S>::put (21 samples, 0.90%) + + + + + core::ptr::drop_in_place<core::option::Option<s4lib::common::ResultS3<(u64,alloc::sync::Arc<s4lib::data::sysline::Sysline>),std::io::error::Error>>> (3 samples, 0.13%) + + + + + <alloc::sync::Arc<T> as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline (916 samples, 39.30%) + + s4lib::readers::syslinereader::SyslineReader::find_sysline + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_year (916 samples, 39.30%) + + s4lib::readers::syslinereader::SyslineReader::find_sysline_year + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_at_datetime_filter_binary_search (918 samples, 39.38%) + + s4lib::readers::syslinereader::SyslineReader::find_sysline_at_da.. + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_between_datetime_filters (919 samples, 39.43%) + + s4lib::readers::syslinereader::SyslineReader::find_sysline_betwe.. + + + s4lib::readers::syslogprocessor::SyslogProcessor::find_sysline_between_datetime_filters (920 samples, 39.47%) + + s4lib::readers::syslogprocessor::SyslogProcessor::find_sysline_b.. + + + lru::LruCache<K,V,S>::pop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<core::option::Option<alloc::sync::Arc<s4lib::data::line::Line>>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<s4lib::data::line::Line>> (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + arena_for_chunk (1 samples, 0.04%) + + + + + __GI___libc_free (2 samples, 0.09%) + + + + + _int_free (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<s4lib::data::line::LinePart> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<alloc::vec::Vec<u8>>> (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<[s4lib::data::line::LinePart]> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<core::iter::adapters::take::Take<alloc::vec::into_iter::IntoIter<s4lib::data::line::LinePart>>> (5 samples, 0.21%) + + + + + core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<s4lib::data::line::LinePart>> (5 samples, 0.21%) + + + + + <alloc::vec::into_iter::IntoIter<T,A> as core::ops::drop::Drop>::drop (3 samples, 0.13%) + + + + + alloc::vec::into_iter::IntoIter<T,A>::as_raw_mut_slice (1 samples, 0.04%) + + + + + alloc::sync::Arc<T>::try_unwrap (8 samples, 0.34%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>::remove (1 samples, 0.04%) + + + + + alloc::collections::btree::node::slice_remove (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::add (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child_edge (1 samples, 0.04%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child (1 samples, 0.04%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::do_merge (1 samples, 0.04%) + + + + + alloc::collections::btree::node::slice_remove (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::add (1 samples, 0.04%) + + + + + core::ptr::mut_ptr::<impl *mut T>::offset (1 samples, 0.04%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (3 samples, 0.13%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (3 samples, 0.13%) + + + + + alloc::collections::btree::fix::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::fix_node_and_affected_ancestors (1 samples, 0.04%) + + + + + alloc::collections::btree::fix::<impl alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>>::fix_node_through_parent (1 samples, 0.04%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_parent (1 samples, 0.04%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::do_merge (1 samples, 0.04%) + + + + + alloc::collections::btree::node::move_to_slice (1 samples, 0.04%) + + + + + core::intrinsics::copy_nonoverlapping (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (4 samples, 0.17%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove (5 samples, 0.21%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove_entry (5 samples, 0.21%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (5 samples, 0.21%) + + + + + s4lib::readers::linereader::LineReader::drop_line (21 samples, 0.90%) + + + + + s4lib::readers::linereader::LineReader::drop_lines (23 samples, 0.99%) + + + + + core::ptr::drop_in_place<alloc::vec::into_iter::IntoIter<alloc::sync::Arc<s4lib::data::line::Line>>> (2 samples, 0.09%) + + + + + __GI___libc_free (2 samples, 0.09%) + + + + + _int_free (2 samples, 0.09%) + + + + + s4lib::data::line::Line::fileoffset_begin (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (1 samples, 0.04%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (1 samples, 0.04%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index (1 samples, 0.04%) + + + + + s4lib::data::sysline::Sysline::fileoffset_begin (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::len (2 samples, 0.09%) + + + + + lru::LruCache<K,V,S>::pop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<core::option::Option<s4lib::common::ResultS3<(u64,alloc::sync::Arc<s4lib::data::sysline::Sysline>),std::io::error::Error>>> (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (7 samples, 0.30%) + + + + + alloc::alloc::dealloc (7 samples, 0.30%) + + + + + __GI___libc_free (7 samples, 0.30%) + + + + + _int_free (7 samples, 0.30%) + + + + + alloc::sync::Arc<T>::try_unwrap (27 samples, 1.16%) + + + + + core::ptr::drop_in_place<alloc::sync::Weak<s4lib::data::sysline::Sysline>> (27 samples, 1.16%) + + + + + <alloc::sync::Weak<T> as core::ops::drop::Drop>::drop (27 samples, 1.16%) + + + + + alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Internal>::correct_childrens_parent_links (1 samples, 0.04%) + + + + + core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.04%) + + + + + <core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.04%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (2 samples, 0.09%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (2 samples, 0.09%) + + + + + alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (2 samples, 0.09%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child_edge (2 samples, 0.09%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::merge_tracking_child (2 samples, 0.09%) + + + + + alloc::collections::btree::node::BalancingContext<K,V>::do_merge (2 samples, 0.09%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove (3 samples, 0.13%) + + + + + alloc::collections::btree::map::BTreeMap<K,V,A>::remove_entry (3 samples, 0.13%) + + + + + alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_entry (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_sysline (60 samples, 2.57%) + + s4.. + + + core::ptr::drop_in_place<alloc::vec::Vec<u64>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<u64>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + malloc_consolidate (1 samples, 0.04%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + malloc_consolidate (14 samples, 0.60%) + + + + + alloc::vec::Vec<T>::with_capacity (18 samples, 0.77%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (18 samples, 0.77%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (18 samples, 0.77%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (18 samples, 0.77%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (18 samples, 0.77%) + + + + + alloc::alloc::Global::alloc_impl (18 samples, 0.77%) + + + + + alloc::alloc::alloc (18 samples, 0.77%) + + + + + __GI___libc_malloc (18 samples, 0.77%) + + + + + _int_malloc (18 samples, 0.77%) + + + + + s4lib::data::sysline::Sysline::blockoffset_last (3 samples, 0.13%) + + + + + s4lib::data::line::Line::blockoffset_last (3 samples, 0.13%) + + + + + core::iter::traits::iterator::Iterator::find::check::{{closure}} (12 samples, 0.51%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (12 samples, 0.51%) + + + + + s4lib::readers::syslinereader::SyslineReader::drop_data::{{closure}} (12 samples, 0.51%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,NodeType>,alloc::collections::btree::node::marker::KV>::into_kv (1 samples, 0.04%) + + + + + core::slice::<impl [T]>::get_unchecked (1 samples, 0.04%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::get_unchecked (1 samples, 0.04%) + + + + + core::ptr::const_ptr::<impl *const T>::add (1 samples, 0.04%) + + + + + core::ptr::const_ptr::<impl *const T>::offset (1 samples, 0.04%) + + + + + <alloc::collections::btree::map::Iter<K,V> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::LazyLeafRange<alloc::collections::btree::node::marker::Immut,K,V>::next_unchecked (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_unchecked (2 samples, 0.09%) + + + + + alloc::collections::btree::mem::replace (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_unchecked::{{closure}} (2 samples, 0.09%) + + + + + alloc::collections::btree::navigate::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>>::next_kv (1 samples, 0.04%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<BorrowType,K,V,NodeType>,alloc::collections::btree::node::marker::Edge>::right_kv (1 samples, 0.04%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::drop_data (94 samples, 4.03%) + + s4li.. + + + s4lib::readers::syslinereader::SyslineReader::drop_data (94 samples, 4.03%) + + s4li.. + + + <core::iter::adapters::filter::Filter<I,P> as core::iter::traits::iterator::Iterator>::next (15 samples, 0.64%) + + + + + core::iter::traits::iterator::Iterator::find (15 samples, 0.64%) + + + + + core::iter::traits::iterator::Iterator::try_fold (15 samples, 0.64%) + + + + + s4lib::data::sysline::Sysline::blockoffset_first (2 samples, 0.09%) + + + + + s4lib::data::line::Line::blockoffset_first (2 samples, 0.09%) + + + + + <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index (2 samples, 0.09%) + + + + + core::slice::index::<impl core::ops::index::Index<I> for [T]>::index (2 samples, 0.09%) + + + + + <usize as core::slice::index::SliceIndex<[T]>>::index (2 samples, 0.09%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::drop_data_try (97 samples, 4.16%) + + s4lib.. + + + core::iter::range::<impl core::iter::traits::iterator::Iterator for core::ops::range::Range<A>>::next (1 samples, 0.04%) + + + + + <core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next (1 samples, 0.04%) + + + + + crossbeam_utils::backoff::Backoff::snooze (11 samples, 0.47%) + + + + + core::hint::spin_loop (10 samples, 0.43%) + + + + + core::core_arch::x86::sse2::_mm_pause (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + [[kernel.kallsyms]] (10 samples, 0.43%) + + + + + std::sync::mutex::Mutex<T>::lock (1 samples, 0.04%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::lock (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + crossbeam_channel::waker::Waker::try_select::{{closure}} (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::remove (1 samples, 0.04%) + + + + + core::ptr::read (1 samples, 0.04%) + + + + + core::mem::maybe_uninit::MaybeUninit<T>::assume_init (1 samples, 0.04%) + + + + + [unknown] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + std::sys::unix::futex::futex_wake (4 samples, 0.17%) + + + + + syscall (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + crossbeam_channel::context::Context::unpark (5 samples, 0.21%) + + + + + std::thread::Thread::unpark (5 samples, 0.21%) + + + + + std::sys_common::thread_parker::futex::Parker::unpark (5 samples, 0.21%) + + + + + crossbeam_channel::context::Context::try_select (6 samples, 0.26%) + + + + + core::result::Result<T,E>::map_err (6 samples, 0.26%) + + + + + crossbeam_channel::waker::Waker::try_select (14 samples, 0.60%) + + + + + <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::position (13 samples, 0.56%) + + + + + crossbeam_channel::waker::Waker::try_select::{{closure}} (13 samples, 0.56%) + + + + + core::cmp::PartialEq::ne (2 samples, 0.09%) + + + + + <std::thread::ThreadId as core::cmp::PartialEq>::eq (2 samples, 0.09%) + + + + + <core::num::nonzero::NonZeroU64 as core::cmp::PartialEq>::eq (2 samples, 0.09%) + + + + + crossbeam_channel::waker::Waker::notify (1 samples, 0.04%) + + + + + core::sync::atomic::AtomicBool::load (1 samples, 0.04%) + + + + + core::sync::atomic::atomic_load (1 samples, 0.04%) + + + + + std::sys::unix::locks::futex_mutex::Mutex::unlock (3 samples, 0.13%) + + + + + core::ptr::drop_in_place<std::sync::mutex::MutexGuard<crossbeam_channel::waker::Waker>> (4 samples, 0.17%) + + + + + <std::sync::mutex::MutexGuard<T> as core::ops::drop::Drop>::drop (4 samples, 0.17%) + + + + + std::sync::poison::Flag::done (1 samples, 0.04%) + + + + + crossbeam_channel::waker::SyncWaker::notify (28 samples, 1.20%) + + + + + core::ptr::drop_in_place<core::option::Option<crossbeam_channel::waker::Entry>> (7 samples, 0.30%) + + + + + core::ptr::drop_in_place<crossbeam_channel::waker::Entry> (7 samples, 0.30%) + + + + + core::ptr::drop_in_place<crossbeam_channel::context::Context> (7 samples, 0.30%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<crossbeam_channel::context::Inner>> (7 samples, 0.30%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (7 samples, 0.30%) + + + + + crossbeam_channel::flavors::array::Channel<T>::write (51 samples, 2.19%) + + c.. + + + core::ptr::mut_ptr::<impl *mut T>::write (23 samples, 0.99%) + + + + + core::ptr::write (23 samples, 0.99%) + + + + + __memmove_avx512_unaligned_erms (23 samples, 0.99%) + + + + + core::sync::atomic::AtomicUsize::compare_exchange_weak (3 samples, 0.13%) + + + + + core::sync::atomic::atomic_compare_exchange_weak (3 samples, 0.13%) + + + + + core::num::<impl usize>::wrapping_add (1 samples, 0.04%) + + + + + crossbeam_channel::flavors::array::Channel<T>::start_send (8 samples, 0.34%) + + + + + std::thread::park (1 samples, 0.04%) + + + + + std::sys_common::thread_parker::futex::Parker::park (1 samples, 0.04%) + + + + + std::sys::unix::futex::futex_wait (1 samples, 0.04%) + + + + + syscall (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + crossbeam_channel::context::Context::with (2 samples, 0.09%) + + + + + std::thread::local::LocalKey<T>::try_with (2 samples, 0.09%) + + + + + crossbeam_channel::context::Context::with::{{closure}} (2 samples, 0.09%) + + + + + crossbeam_channel::context::Context::with::{{closure}} (2 samples, 0.09%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send::{{closure}} (2 samples, 0.09%) + + + + + crossbeam_channel::context::Context::wait_until (2 samples, 0.09%) + + + + + crossbeam_utils::backoff::Backoff::snooze (1 samples, 0.04%) + + + + + core::hint::spin_loop (1 samples, 0.04%) + + + + + core::core_arch::x86::sse2::_mm_pause (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (4 samples, 0.17%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send (77 samples, 3.30%) + + cro.. + + + __memmove_avx512_unaligned_erms (3 samples, 0.13%) + + + + + crossbeam_channel::channel::Sender<T>::send (82 samples, 3.52%) + + cro.. + + + s4::chan_send (83 samples, 3.56%) + + s4::.. + + + core::ptr::drop_in_place<alloc::sync::Arc<s4lib::data::sysline::Sysline>> (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + __clone3 (1,170 samples, 50.19%) + + __clone3 + + + start_thread (1,170 samples, 50.19%) + + start_thread + + + std::sys::unix::thread::Thread::new::thread_start (1,170 samples, 50.19%) + + std::sys::unix::thread::Thread::new::thread_start + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1,170 samples, 50.19%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once (1,170 samples, 50.19%) + + <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (1,170 samples, 50.19%) + + core::ops::function::FnOnce::call_once{{vtable.shim}} + + + std::thread::Builder::spawn_unchecked_::{{closure}} (1,170 samples, 50.19%) + + std::thread::Builder::spawn_unchecked_::{{closure}} + + + std::panic::catch_unwind (1,170 samples, 50.19%) + + std::panic::catch_unwind + + + std::panicking::try (1,170 samples, 50.19%) + + std::panicking::try + + + std::panicking::try::do_call (1,170 samples, 50.19%) + + std::panicking::try::do_call + + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once (1,170 samples, 50.19%) + + <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>:.. + + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} (1,170 samples, 50.19%) + + std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}} + + + std::sys_common::backtrace::__rust_begin_short_backtrace (1,170 samples, 50.19%) + + std::sys_common::backtrace::__rust_begin_short_backtrace + + + s4::processing_loop::{{closure}} (1,170 samples, 50.19%) + + s4::processing_loop::{{closure}} + + + s4::exec_fileprocessor_thread (1,170 samples, 50.19%) + + s4::exec_fileprocessor_thread + + + s4::exec_syslogprocessor (1,170 samples, 50.19%) + + s4::exec_syslogprocessor + + + regex_syntax::hir::literal::PreferenceTrie::create_state (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::prefixes (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::retain_mut (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::retain_mut::process_loop (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + checked_request2size (1 samples, 0.04%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (3 samples, 0.13%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (3 samples, 0.13%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (3 samples, 0.13%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (3 samples, 0.13%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (3 samples, 0.13%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (3 samples, 0.13%) + + + + + once_cell::imp::OnceCell<T>::initialize (3 samples, 0.13%) + + + + + once_cell::imp::initialize_or_wait (3 samples, 0.13%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (3 samples, 0.13%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (3 samples, 0.13%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (3 samples, 0.13%) + + + + + regex::regex::bytes::Regex::new (3 samples, 0.13%) + + + + + regex::builders::bytes::RegexBuilder::build (3 samples, 0.13%) + + + + + regex::builders::Builder::build_one_bytes (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::new (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::ReverseSuffix::new (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::suffixes (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Extractor::extract_concat (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Extractor::extract_concat (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Extractor::cross (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Seq::cross_reverse (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_syntax::hir::literal::Literal> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<u8>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<u8>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::Inner::into_nfa (1 samples, 0.04%) + + + + + regex_automata::util::alphabet::ByteClassSet::byte_classes (1 samples, 0.04%) + + + + + regex_automata::util::alphabet::ByteSet::contains (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (2 samples, 0.09%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (2 samples, 0.09%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (2 samples, 0.09%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (2 samples, 0.09%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (2 samples, 0.09%) + + + + + once_cell::imp::OnceCell<T>::initialize (2 samples, 0.09%) + + + + + once_cell::imp::initialize_or_wait (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (2 samples, 0.09%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (2 samples, 0.09%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (2 samples, 0.09%) + + + + + regex::regex::bytes::Regex::new (2 samples, 0.09%) + + + + + regex::builders::bytes::RegexBuilder::build (2 samples, 0.09%) + + + + + regex::builders::Builder::build_one_bytes (2 samples, 0.09%) + + + + + regex_automata::meta::regex::Builder::build (2 samples, 0.09%) + + + + + regex_automata::meta::regex::Builder::build_many (2 samples, 0.09%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (2 samples, 0.09%) + + + + + regex_automata::meta::strategy::new (2 samples, 0.09%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::resize (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::Inner::remap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::State::remap (1 samples, 0.04%) + + + + + regex_automata::util::primitives::<impl core::ops::index::Index<regex_automata::util::primitives::StateID> for [T]>::index (1 samples, 0.04%) + + + + + regex_automata::util::primitives::StateID::new (1 samples, 0.04%) + + + + + regex_automata::util::primitives::SmallIndex::new (1 samples, 0.04%) + + + + + <regex_automata::util::primitives::SmallIndex as core::convert::TryFrom<usize>>::try_from (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::Inner::add (3 samples, 0.13%) + + + + + regex_automata::util::alphabet::ByteClassSet::set_range (2 samples, 0.09%) + + + + + regex_automata::util::alphabet::ByteSet::add (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::builder::State::goto (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + alloc::slice::<impl [T]>::to_vec (1 samples, 0.04%) + + + + + alloc::slice::<impl [T]>::to_vec_in (1 samples, 0.04%) + + + + + alloc::slice::hack::to_vec (1 samples, 0.04%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (8 samples, 0.34%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (8 samples, 0.34%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (8 samples, 0.34%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (8 samples, 0.34%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (8 samples, 0.34%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (8 samples, 0.34%) + + + + + once_cell::imp::OnceCell<T>::initialize (8 samples, 0.34%) + + + + + once_cell::imp::initialize_or_wait (8 samples, 0.34%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (8 samples, 0.34%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (8 samples, 0.34%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (8 samples, 0.34%) + + + + + regex::regex::bytes::Regex::new (8 samples, 0.34%) + + + + + regex::builders::bytes::RegexBuilder::build (8 samples, 0.34%) + + + + + regex::builders::Builder::build_one_bytes (8 samples, 0.34%) + + + + + regex_automata::meta::regex::Builder::build (8 samples, 0.34%) + + + + + regex_automata::meta::regex::Builder::build_many (8 samples, 0.34%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (8 samples, 0.34%) + + + + + regex_automata::meta::strategy::new (8 samples, 0.34%) + + + + + regex_automata::meta::strategy::Core::new (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (8 samples, 0.34%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (1 samples, 0.04%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (1 samples, 0.04%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (1 samples, 0.04%) + + + + + once_cell::imp::OnceCell<T>::initialize (1 samples, 0.04%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.04%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.04%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.04%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.04%) + + + + + regex::builders::bytes::RegexBuilder::build (1 samples, 0.04%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::build (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::nfa::Inner::into_nfa (1 samples, 0.04%) + + + + + regex_automata::util::sparse_set::SparseSet::new (1 samples, 0.04%) + + + + + regex_automata::util::sparse_set::SparseSet::resize (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::resize (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_with (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + sysmalloc (1 samples, 0.04%) + + + + + grow_heap (1 samples, 0.04%) + + + + + __GI___mprotect (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::State::add_match (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + <core::result::Result<T,E> as core::ops::try_trait::Try>::branch (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (3 samples, 0.13%) + + + + + core::ptr::write (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (5 samples, 0.21%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __rdl_alloc (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<(usize,usize)>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<(usize,usize)>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (7 samples, 0.30%) + + + + + core::option::Option<T>::map (7 samples, 0.30%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (7 samples, 0.30%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (7 samples, 0.30%) + + + + + <core::iter::adapters::filter::Filter<I,P> as core::iter::traits::iterator::Iterator>::count (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::sum (1 samples, 0.04%) + + + + + <usize as core::iter::traits::accum::Sum>::sum (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::fold (1 samples, 0.04%) + + + + + core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.04%) + + + + + <core::iter::adapters::filter::Filter<I,P> as core::iter::traits::iterator::Iterator>::count::to_usize::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::get_or_add_state (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::push (2 samples, 0.09%) + + + + + core::ptr::write (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (11 samples, 0.47%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (11 samples, 0.47%) + + + + + core::option::Option<T>::map (11 samples, 0.47%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (11 samples, 0.47%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (11 samples, 0.47%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (4 samples, 0.17%) + + + + + core::option::Option<T>::map (4 samples, 0.17%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 0.17%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (4 samples, 0.17%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<(usize,usize)>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<(usize,usize)>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (15 samples, 0.64%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (15 samples, 0.64%) + + + + + once_cell::imp::OnceCell<T>::initialize (15 samples, 0.64%) + + + + + once_cell::imp::initialize_or_wait (15 samples, 0.64%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (15 samples, 0.64%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (15 samples, 0.64%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (15 samples, 0.64%) + + + + + regex::regex::bytes::Regex::new (15 samples, 0.64%) + + + + + regex::builders::bytes::RegexBuilder::build (15 samples, 0.64%) + + + + + regex::builders::Builder::build_one_bytes (15 samples, 0.64%) + + + + + regex_automata::meta::regex::Builder::build (15 samples, 0.64%) + + + + + regex_automata::meta::regex::Builder::build_many (15 samples, 0.64%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (15 samples, 0.64%) + + + + + regex_automata::meta::strategy::new (15 samples, 0.64%) + + + + + regex_automata::meta::strategy::Core::new (15 samples, 0.64%) + + + + + regex_automata::meta::wrappers::OnePass::new (4 samples, 0.17%) + + + + + regex_automata::meta::wrappers::OnePassEngine::new (4 samples, 0.17%) + + + + + regex_automata::dfa::onepass::Builder::build_from_nfa (4 samples, 0.17%) + + + + + regex_automata::dfa::onepass::InternalBuilder::build (4 samples, 0.17%) + + + + + regex_automata::dfa::onepass::InternalBuilder::compile_transition (4 samples, 0.17%) + + + + + regex_automata::dfa::onepass::InternalBuilder::add_dfa_state_for_nfa_state (4 samples, 0.17%) + + + + + regex_automata::dfa::onepass::InternalBuilder::add_empty_state (4 samples, 0.17%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (4 samples, 0.17%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (4 samples, 0.17%) + + + + + <core::iter::adapters::take::Take<I> as core::iter::traits::iterator::Iterator>::for_each (4 samples, 0.17%) + + + + + core::iter::traits::iterator::Iterator::try_fold (4 samples, 0.17%) + + + + + <core::iter::adapters::take::Take<I> as core::iter::traits::iterator::Iterator>::for_each::check::{{closure}} (4 samples, 0.17%) + + + + + alloc::vec::Vec<T,A>::extend_trusted::{{closure}} (4 samples, 0.17%) + + + + + core::ptr::write (4 samples, 0.17%) + + + + + __memset_avx512_unaligned_erms (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::prefixes (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Extractor::extract (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Extractor::extract_concat (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Extractor::cross (2 samples, 0.09%) + + + + + regex_syntax::hir::literal::Seq::cross_forward (2 samples, 0.09%) + + + + + alloc::vec::Vec<T>::with_capacity (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (2 samples, 0.09%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (2 samples, 0.09%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (2 samples, 0.09%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (2 samples, 0.09%) + + + + + alloc::alloc::Global::alloc_impl (2 samples, 0.09%) + + + + + alloc::alloc::alloc (2 samples, 0.09%) + + + + + __GI___libc_malloc (2 samples, 0.09%) + + + + + regex_automata::meta::reverse_inner::top_concat (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::collect (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter_nested::SpecFromIterNested<T,I>>::from_iter (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::for_each (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::fold (1 samples, 0.04%) + + + + + core::iter::traits::iterator::Iterator::fold (1 samples, 0.04%) + + + + + core::iter::adapters::map::map_fold::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::meta::reverse_inner::top_concat::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::meta::reverse_inner::flatten (1 samples, 0.04%) + + + + + regex_automata::meta::reverse_inner::prefilter (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Seq::optimize_for_prefix_by_preference (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::Seq::optimize_by_preference (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::retain_mut (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::retain_mut::process_loop (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::PreferenceTrie::minimize::{{closure}} (1 samples, 0.04%) + + + + + regex_syntax::hir::literal::PreferenceTrie::insert (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::insert (1 samples, 0.04%) + + + + + core::intrinsics::copy (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::ReverseInner::new (3 samples, 0.13%) + + + + + regex_automata::meta::reverse_inner::extract (3 samples, 0.13%) + + + + + core::ptr::drop_in_place<regex_automata::util::prefilter::Prefilter> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::sync::Arc<dyn regex_automata::util::prefilter::PrefilterI>> (1 samples, 0.04%) + + + + + <alloc::sync::Arc<T> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + alloc::sync::Arc<T>::drop_slow (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<dyn regex_automata::meta::strategy::Strategy> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<aho_corasick::dfa::DFA> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<alloc::vec::Vec<aho_corasick::util::primitives::PatternID>>> (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<[alloc::vec::Vec<aho_corasick::util::primitives::PatternID>]> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<aho_corasick::util::primitives::PatternID>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<aho_corasick::util::primitives::PatternID>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + s4::exec_fileprocessor_thread (7 samples, 0.30%) + + + + + s4::exec_syslogprocessor (7 samples, 0.30%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::process_stage1_blockzero_analysis (7 samples, 0.30%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis (7 samples, 0.30%) + + + + + s4lib::readers::syslogprocessor::SyslogProcessor::blockzero_analysis_syslines (7 samples, 0.30%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block (7 samples, 0.30%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_sysline_in_block_year (7 samples, 0.30%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line_cached (7 samples, 0.30%) + + + + + s4lib::readers::syslinereader::SyslineReader::parse_datetime_in_line (7 samples, 0.30%) + + + + + s4lib::readers::syslinereader::SyslineReader::find_datetime_in_line (7 samples, 0.30%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime (7 samples, 0.30%) + + + + + once_cell::sync::OnceCell<T>::get_or_try_init (7 samples, 0.30%) + + + + + once_cell::imp::OnceCell<T>::initialize (7 samples, 0.30%) + + + + + once_cell::imp::initialize_or_wait (7 samples, 0.30%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (7 samples, 0.30%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (7 samples, 0.30%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (7 samples, 0.30%) + + + + + regex::regex::bytes::Regex::new (7 samples, 0.30%) + + + + + regex::builders::bytes::RegexBuilder::build (7 samples, 0.30%) + + + + + regex::builders::Builder::build_one_bytes (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Builder::build (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Builder::build_many (7 samples, 0.30%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (7 samples, 0.30%) + + + + + regex_automata::meta::strategy::new (7 samples, 0.30%) + + + + + regex_automata::meta::strategy::Core::new (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::builder::Builder>> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<core::cell::UnsafeCell<regex_automata::nfa::thompson::builder::Builder>> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::Builder> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::builder::State>> (2 samples, 0.09%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::builder::State]> (2 samples, 0.09%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::builder::State> (2 samples, 0.09%) + + + + + __GI___libc_free (2 samples, 0.09%) + + + + + _int_free (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::shrink_to_fit (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::shrink_to_fit (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::shrink (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::shrink (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + unlink_chunk (1 samples, 0.04%) + + + + + <core::iter::sources::from_fn::FromFn<F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + aho_corasick::nfa::noncontiguous::NFA::iter_trans::{{closure}} (1 samples, 0.04%) + + + + + <aho_corasick::util::primitives::StateID as core::cmp::PartialEq>::eq (1 samples, 0.04%) + + + + + <aho_corasick::util::primitives::SmallIndex as core::cmp::PartialEq>::eq (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (3 samples, 0.13%) + + + + + aho_corasick::dfa::Builder::build (3 samples, 0.13%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (3 samples, 0.13%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::compile (3 samples, 0.13%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::build_trie (2 samples, 0.09%) + + + + + aho_corasick::nfa::noncontiguous::NFA::follow_transition (2 samples, 0.09%) + + + + + aho_corasick::nfa::noncontiguous::NFA::follow_transition_sparse (2 samples, 0.09%) + + + + + regex_automata::meta::strategy::ReverseInner::new (4 samples, 0.17%) + + + + + regex_automata::meta::reverse_inner::extract (4 samples, 0.17%) + + + + + regex_automata::meta::reverse_inner::prefilter (4 samples, 0.17%) + + + + + core::option::Option<T>::and_then (4 samples, 0.17%) + + + + + regex_automata::meta::reverse_inner::prefilter::{{closure}} (4 samples, 0.17%) + + + + + regex_automata::util::prefilter::Prefilter::new (4 samples, 0.17%) + + + + + regex_automata::util::prefilter::Choice::new (4 samples, 0.17%) + + + + + regex_automata::util::prefilter::aho_corasick::AhoCorasick::new (1 samples, 0.04%) + + + + + aho_corasick::ahocorasick::AhoCorasickBuilder::build (1 samples, 0.04%) + + + + + aho_corasick::nfa::noncontiguous::Builder::build (1 samples, 0.04%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::compile (1 samples, 0.04%) + + + + + aho_corasick::nfa::noncontiguous::Compiler::densify (1 samples, 0.04%) + + + + + aho_corasick::nfa::noncontiguous::NFA::alloc_dense_state (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::iter::traits::collect::Extend<T>>::extend (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<T,I>>::spec_extend (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::extend_trusted (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::new (5 samples, 0.21%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.04%) + + + + + regex_automata::meta::wrappers::Hybrid::new (1 samples, 0.04%) + + + + + regex_automata::meta::wrappers::HybridEngine::new (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::Builder::build_from_nfa (1 samples, 0.04%) + + + + + regex_automata::hybrid::dfa::Config::byte_classes_from_nfa (1 samples, 0.04%) + + + + + regex_automata::util::alphabet::ByteClassSet::byte_classes (1 samples, 0.04%) + + + + + regex_automata::util::alphabet::ByteSet::contains (1 samples, 0.04%) + + + + + aho_corasick::util::alphabet::ByteClasses::get (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::ReverseInner::new (3 samples, 0.13%) + + + + + regex_automata::meta::reverse_inner::extract (3 samples, 0.13%) + + + + + regex_automata::meta::reverse_inner::prefilter (3 samples, 0.13%) + + + + + core::option::Option<T>::and_then (3 samples, 0.13%) + + + + + regex_automata::meta::reverse_inner::prefilter::{{closure}} (3 samples, 0.13%) + + + + + regex_automata::util::prefilter::Prefilter::new (3 samples, 0.13%) + + + + + regex_automata::util::prefilter::Choice::new (3 samples, 0.13%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (3 samples, 0.13%) + + + + + aho_corasick::dfa::Builder::build (3 samples, 0.13%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (3 samples, 0.13%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start (3 samples, 0.13%) + + + + + aho_corasick::dfa::sparse_iter (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::with_capacity_in (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::allocate_in (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::allocate (1 samples, 0.04%) + + + + + alloc::alloc::Global::alloc_impl (1 samples, 0.04%) + + + + + alloc::alloc::alloc (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + malloc_consolidate (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + core::ptr::write (4 samples, 0.17%) + + + + + <regex_automata::util::primitives::StateID as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (8 samples, 0.34%) + + + + + alloc::vec::from_elem (8 samples, 0.34%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (8 samples, 0.34%) + + + + + alloc::vec::Vec<T,A>::extend_with (7 samples, 0.30%) + + + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (3 samples, 0.13%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (3 samples, 0.13%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (2 samples, 0.09%) + + + + + alloc::slice::<impl [T]>::to_vec_in (2 samples, 0.09%) + + + + + alloc::slice::hack::to_vec (2 samples, 0.09%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (2 samples, 0.09%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (2 samples, 0.09%) + + + + + core::intrinsics::copy_nonoverlapping (2 samples, 0.09%) + + + + + __memmove_avx512_unaligned_erms (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (9 samples, 0.39%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::finish (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::compile_from (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_sparse (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 0.51%) + + + + + core::option::Option<T>::map (12 samples, 0.51%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 0.51%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 0.51%) + + + + + core::option::Option<T>::map (12 samples, 0.51%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 0.13%) + + + + + core::option::Option<T>::map (3 samples, 0.13%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (3 samples, 0.13%) + + + + + alloc::vec::from_elem (3 samples, 0.13%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (3 samples, 0.13%) + + + + + alloc::vec::Vec<T,A>::extend_with (3 samples, 0.13%) + + + + + core::ptr::write (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_repetition (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_zero_or_one (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::add_empty (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_empty (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::Core::new (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (14 samples, 0.60%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (14 samples, 0.60%) + + + + + core::option::Option<T>::map (14 samples, 0.60%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (14 samples, 0.60%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (14 samples, 0.60%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (2 samples, 0.09%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (2 samples, 0.09%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_literal (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_literal::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_range (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::add_range (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_range (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build (18 samples, 0.77%) + + + + + regex_automata::meta::regex::Builder::build_many (18 samples, 0.77%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (18 samples, 0.77%) + + + + + regex_automata::meta::strategy::new (18 samples, 0.77%) + + + + + core::option::Option<T>::and_then (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::new::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::Prefilter::new (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::Choice::new (1 samples, 0.04%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::build (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start (1 samples, 0.04%) + + + + + aho_corasick::dfa::sparse_iter (1 samples, 0.04%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 0.04%) + + + + + core::convert::num::<impl core::convert::From<u8> for usize>::from (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_sparse (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (2 samples, 0.09%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + regex::regex::bytes::Regex::new (3 samples, 0.13%) + + + + + regex::builders::bytes::RegexBuilder::build (3 samples, 0.13%) + + + + + regex::builders::Builder::build_one_bytes (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::new (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::Core::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 0.13%) + + + + + core::option::Option<T>::map (3 samples, 0.13%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::LiteralTrie> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::State>> (1 samples, 0.04%) + + + + + <alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<[regex_automata::nfa::thompson::literal_trie::State]> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::literal_trie::State> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::vec::Vec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.04%) + + + + + core::ptr::drop_in_place<alloc::raw_vec::RawVec<regex_automata::nfa::thompson::literal_trie::Transition>> (1 samples, 0.04%) + + + + + <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::deallocate (1 samples, 0.04%) + + + + + alloc::alloc::dealloc (1 samples, 0.04%) + + + + + __GI___libc_free (1 samples, 0.04%) + + + + + _int_free (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (2 samples, 0.09%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + [[kernel.kallsyms]] (3 samples, 0.13%) + + + + + core::ptr::write (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + [[kernel.kallsyms]] (4 samples, 0.17%) + + + + + <regex_automata::util::primitives::StateID as core::clone::Clone>::clone (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (9 samples, 0.39%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (9 samples, 0.39%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (9 samples, 0.39%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (9 samples, 0.39%) + + + + + core::option::Option<T>::map (9 samples, 0.39%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (9 samples, 0.39%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (9 samples, 0.39%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::compiler::Utf8State::clear (8 samples, 0.34%) + + + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (8 samples, 0.34%) + + + + + alloc::vec::from_elem (8 samples, 0.34%) + + + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (8 samples, 0.34%) + + + + + alloc::vec::Vec<T,A>::extend_with (8 samples, 0.34%) + + + + + <alloc::vec::ExtendElement<T> as alloc::vec::ExtendWith<T>>::next (4 samples, 0.17%) + + + + + <regex_automata::nfa::thompson::map::Utf8BoundedEntry as core::clone::Clone>::clone (4 samples, 0.17%) + + + + + <alloc::vec::Vec<T,A> as core::clone::Clone>::clone (3 samples, 0.13%) + + + + + alloc::slice::<impl [T]>::to_vec_in (3 samples, 0.13%) + + + + + alloc::slice::hack::to_vec (3 samples, 0.13%) + + + + + <T as alloc::slice::hack::ConvertVec>::to_vec (3 samples, 0.13%) + + + + + core::ptr::const_ptr::<impl *const T>::copy_to_nonoverlapping (3 samples, 0.13%) + + + + + core::intrinsics::copy_nonoverlapping (3 samples, 0.13%) + + + + + __memmove_avx512_unaligned_erms (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (10 samples, 0.43%) + + + + + core::option::Option<T>::map (10 samples, 0.43%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (10 samples, 0.43%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (10 samples, 0.43%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_repetition (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_zero_or_one (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::add_empty (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_empty (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + <alloc::alloc::Global as core::alloc::Allocator>::grow (1 samples, 0.04%) + + + + + alloc::alloc::Global::grow_impl (1 samples, 0.04%) + + + + + alloc::alloc::realloc (1 samples, 0.04%) + + + + + __GI___libc_realloc (1 samples, 0.04%) + + + + + _int_realloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + sysmalloc (1 samples, 0.04%) + + + + + [[kernel.kallsyms]] (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.04%) + + + + + regex::builders::Builder::build_one_bytes (12 samples, 0.51%) + + + + + regex_automata::meta::regex::Builder::build (12 samples, 0.51%) + + + + + regex_automata::meta::regex::Builder::build_many (12 samples, 0.51%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (12 samples, 0.51%) + + + + + regex_automata::meta::strategy::new (12 samples, 0.51%) + + + + + regex_automata::meta::strategy::Core::new (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (12 samples, 0.51%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (12 samples, 0.51%) + + + + + core::option::Option<T>::map (12 samples, 0.51%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (12 samples, 0.51%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (12 samples, 0.51%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_unicode_class_reverse_with_suffix (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::patch (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::patch (1 samples, 0.04%) + + + + + once_cell::imp::initialize_or_wait (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnMut<A> for &mut F>::call_mut (1 samples, 0.04%) + + + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (1 samples, 0.04%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (1 samples, 0.04%) + + + + + regex::regex::bytes::Regex::new (1 samples, 0.04%) + + + + + regex::builders::bytes::RegexBuilder::build (1 samples, 0.04%) + + + + + regex::builders::Builder::build_one_bytes (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many (1 samples, 0.04%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::new (1 samples, 0.04%) + + + + + regex_automata::meta::strategy::Core::new (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_union (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + core::alloc::layout::Layout::array (1 samples, 0.04%) + + + + + core::alloc::layout::Layout::array::inner (1 samples, 0.04%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (2 samples, 0.09%) + + + + + core::option::Option<T>::map (2 samples, 0.09%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (2 samples, 0.09%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::add (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::State::add_match (1 samples, 0.04%) + + + + + alloc::vec::Vec<T,A>::push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve_for_push (1 samples, 0.04%) + + + + + alloc::raw_vec::RawVec<T,A>::grow_amortized (1 samples, 0.04%) + + + + + alloc::raw_vec::finish_grow (1 samples, 0.04%) + + + + + __GI___libc_malloc (1 samples, 0.04%) + + + + + _int_malloc (1 samples, 0.04%) + + + + + all (2,331 samples, 100%) + + + + + gen-99999-1-Mot (1,248 samples, 53.54%) + + gen-99999-1-Mot + + + [unknown] (78 samples, 3.35%) + + [un.. + + + once_cell::imp::OnceCell<T>::initialize::{{closure}} (3 samples, 0.13%) + + + + + s4lib::data::datetime::bytes_to_regex_to_datetime::{{closure}} (3 samples, 0.13%) + + + + + regex::regex::bytes::Regex::new (3 samples, 0.13%) + + + + + regex::builders::bytes::RegexBuilder::build (3 samples, 0.13%) + + + + + regex::builders::Builder::build_one_bytes (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many (3 samples, 0.13%) + + + + + regex_automata::meta::regex::Builder::build_many_from_hir (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::new (3 samples, 0.13%) + + + + + regex_automata::meta::strategy::Core::new (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (3 samples, 0.13%) + + + + + core::option::Option<T>::map (3 samples, 0.13%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::compile::{{closure}} (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (3 samples, 0.13%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_concat (3 samples, 0.13%) + + + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::double_ended::DoubleEndedIterator>::next_back (1 samples, 0.04%) + + + + + core::option::Option<T>::map (1 samples, 0.04%) + + + + + core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &mut F>::call_once (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c::{{closure}} (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_slice (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::literal_trie::LiteralTrie::compile (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add_union (1 samples, 0.04%) + + + + + regex_automata::nfa::thompson::builder::Builder::add (1 samples, 0.04%) + + + + + diff --git a/releases/0.6.71/flamegraph-utmp.svg b/releases/0.6.71/flamegraph-utmp.svg new file mode 100644 index 00000000..3036e177 --- /dev/null +++ b/releases/0.6.71/flamegraph-utmp.svg @@ -0,0 +1,2202 @@ + + + + + + + + + + + + + + + Flame Graph: super_speedy_syslog_searcher 0.6.71; git: 369bf08; -freq 20000; created 20240416T001051-0700
; s4 ./logs/CentOS7/x86_64/wtmp + + Reset Zoom + Search + + + + s4lib::readers::fixedstructreader::FixedStructReader::process_entry_at (1 samples, 1.12%) + + + + + s4lib::readers::fixedstructreader::FixedStructReader::score_file (1 samples, 1.12%) + + + + + s4lib::readers::blockreader::BlockReader::read_data_to_buffer (1 samples, 1.12%) + + + + + s4lib::readers::blockreader::BlockReader::read_block (1 samples, 1.12%) + + + + + std::io::Read::read_to_end (1 samples, 1.12%) + + + + + <&std::fs::File as std::io::Read>::read_buf (1 samples, 1.12%) + + + + + read (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + s4lib::readers::blockreader::BlockReader::new (1 samples, 1.12%) + + + + + std::fs::OpenOptions::_open (1 samples, 1.12%) + + + + + std::sys::unix::fs::File::open_c (1 samples, 1.12%) + + + + + __GI___libc_open (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + s4lib::readers::fixedstructreader::FixedStructReader::new (3 samples, 3.37%) + + s4l.. + + + alloc::collections::btree::map::entry::VacantEntry<K,V,A>::insert (1 samples, 1.12%) + + + + + alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (1 samples, 1.12%) + + + + + std::sys_common::backtrace::__rust_begin_short_backtrace (5 samples, 5.62%) + + std::sy.. + + + s4::exec_fileprocessor_thread (5 samples, 5.62%) + + s4::exe.. + + + crossbeam_channel::channel::Sender<T>::send (1 samples, 1.12%) + + + + + crossbeam_channel::flavors::array::Channel<T>::send (1 samples, 1.12%) + + + + + __memmove_avx512_unaligned_erms (1 samples, 1.12%) + + + + + std::sys::unix::thread::Thread::new::thread_start (6 samples, 6.74%) + + std::sys:.. + + + core::ops::function::FnOnce::call_once{{vtable.shim}} (6 samples, 6.74%) + + core::ops.. + + + std::sys::unix::thread::guard::current (1 samples, 1.12%) + + + + + pthread_getattr_np@@GLIBC_2.32 (1 samples, 1.12%) + + + + + malloc (1 samples, 1.12%) + + + + + tcache_init.part.0 (1 samples, 1.12%) + + + + + arena_get2.part.0 (1 samples, 1.12%) + + + + + alloc_new_heap (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + wtmp (7 samples, 7.87%) + + wtmp + + + clone3 (7 samples, 7.87%) + + clone3 + + + start_thread (7 samples, 7.87%) + + start_thread + + + __madvise (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + start_thread (1 samples, 1.12%) + + + + + std::sys::unix::thread::Thread::new::thread_start (1 samples, 1.12%) + + + + + std::sys::unix::stack_overflow::imp::make_handler (1 samples, 1.12%) + + + + + __mprotect (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + clone3 (2 samples, 2.25%) + + c.. + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + init_cpu_features.constprop.0 (1 samples, 1.12%) + + + + + handle_amd (1 samples, 1.12%) + + + + + access (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + mprotect (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + check_match (1 samples, 1.12%) + + + + + strcmp (1 samples, 1.12%) + + + + + _dl_lookup_symbol_x (2 samples, 2.25%) + + _.. + + + do_lookup_x (2 samples, 2.25%) + + d.. + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (5 samples, 5.62%) + + [[kerne.. + + + _dl_relocate_object (9 samples, 10.11%) + + _dl_relocate_ob.. + + + _dl_receive_error (1 samples, 1.12%) + + + + + version_check_doit (1 samples, 1.12%) + + + + + _dl_check_all_versions (1 samples, 1.12%) + + + + + _dl_check_map_versions (1 samples, 1.12%) + + + + + mprotect (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + _dl_start (14 samples, 15.73%) + + _dl_start + + + _dl_sysdep_start (14 samples, 15.73%) + + _dl_sysdep_start + + + dl_main (13 samples, 14.61%) + + dl_main + + + _dl_map_object_deps (2 samples, 2.25%) + + _.. + + + _dl_catch_exception (2 samples, 2.25%) + + _.. + + + openaux (2 samples, 2.25%) + + o.. + + + _dl_map_object (2 samples, 2.25%) + + _.. + + + _dl_map_object_from_fd (2 samples, 2.25%) + + _.. + + + mmap64 (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 1.12%) + + + + + __munmap (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + s4lib::readers::filepreprocessor::process_path (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + s4::processing_loop (2 samples, 2.25%) + + s.. + + + s4lib::printer::printers::PrinterLogMessage::print_fixedstruct_color (2 samples, 2.25%) + + s.. + + + std::io::Write::write_all (2 samples, 2.25%) + + s.. + + + <termcolor::LossyStandardStream<W> as std::io::Write>::write (2 samples, 2.25%) + + <.. + + + <std::io::stdio::Stdout as std::io::Write>::write (2 samples, 2.25%) + + <.. + + + <&std::io::stdio::Stdout as std::io::Write>::write (2 samples, 2.25%) + + <.. + + + <std::io::stdio::StdoutLock as std::io::Write>::write (2 samples, 2.25%) + + <.. + + + __GI___libc_write (2 samples, 2.25%) + + _.. + + + [[kernel.kallsyms]] (2 samples, 2.25%) + + [.. + + + [[kernel.kallsyms]] (2 samples, 2.25%) + + [.. + + + s4::string_wdhms_to_duration (1 samples, 1.12%) + + + + + std::sys_common::once::futex::Once::call (1 samples, 1.12%) + + + + + regex::regex::string::Regex::new (1 samples, 1.12%) + + + + + regex::builders::Builder::build_one_string (1 samples, 1.12%) + + + + + regex_automata::meta::regex::Builder::build (1 samples, 1.12%) + + + + + regex_syntax::ast::parse::Parser::parse (1 samples, 1.12%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_with_comments (1 samples, 1.12%) + + + + + regex_syntax::ast::parse::ParserI<P>::push_group (1 samples, 1.12%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_group (1 samples, 1.12%) + + + + + regex_syntax::ast::parse::ParserI<P>::parse_capture_name (1 samples, 1.12%) + + + + + alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (1 samples, 1.12%) + + + + + alloc::raw_vec::finish_grow (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + std::rt::lang_start::_{{closure}} (5 samples, 5.62%) + + std::rt.. + + + std::sys_common::backtrace::__rust_begin_short_backtrace (5 samples, 5.62%) + + std::sy.. + + + s4::main (5 samples, 5.62%) + + s4::main + + + s4::cli_process_args (2 samples, 2.25%) + + s.. + + + clap_builder::builder::command::Command::get_matches_from (1 samples, 1.12%) + + + + + clap_builder::builder::command::Command::_do_parse (1 samples, 1.12%) + + + + + clap_builder::parser::parser::Parser::get_matches_with (1 samples, 1.12%) + + + + + clap_builder::parser::parser::Parser::add_defaults (1 samples, 1.12%) + + + + + <alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1 samples, 1.12%) + + + + + pthread_getaffinity_np@GLIBC_2.3.4 (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + __libc_start_main@@GLIBC_2.34 (8 samples, 8.99%) + + __libc_start_.. + + + __libc_start_call_main (8 samples, 8.99%) + + __libc_start_.. + + + main (8 samples, 8.99%) + + main + + + std::rt::lang_start_internal (8 samples, 8.99%) + + std::rt::lang.. + + + pthread_getattr_np@@GLIBC_2.32 (2 samples, 2.25%) + + p.. + + + fopen@@GLIBC_2.2.5 (1 samples, 1.12%) + + + + + malloc (1 samples, 1.12%) + + + + + tcache_init.part.0 (1 samples, 1.12%) + + + + + _int_malloc (1 samples, 1.12%) + + + + + sysmalloc (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + _start (23 samples, 25.84%) + + _start + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + regex_automata::util::prefilter::prefixes (1 samples, 1.12%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 1.12%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 1.12%) + + + + + regex_syntax::hir::literal::Extractor::extract (1 samples, 1.12%) + + + + + s4::string_wdhms_to_duration (2 samples, 2.25%) + + s.. + + + std::sys_common::once::futex::Once::call (2 samples, 2.25%) + + s.. + + + regex::regex::string::Regex::new (2 samples, 2.25%) + + r.. + + + regex::builders::Builder::build_one_string (2 samples, 2.25%) + + r.. + + + regex_automata::meta::regex::Builder::build (2 samples, 2.25%) + + r.. + + + regex_automata::meta::strategy::new (2 samples, 2.25%) + + r.. + + + core::ptr::drop_in_place<regex_automata::nfa::thompson::compiler::Compiler> (1 samples, 1.12%) + + + + + core::ptr::drop_in_place<core::cell::RefCell<regex_automata::nfa::thompson::compiler::Utf8State>> (1 samples, 1.12%) + + + + + cfree@GLIBC_2.2.5 (1 samples, 1.12%) + + + + + __munmap (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + s4::cli_process_args (4 samples, 4.49%) + + s4::c.. + + + <s4::CLI_Args as clap_builder::derive::Args>::augment_args (2 samples, 2.25%) + + <.. + + + __memmove_avx512_unaligned_erms (2 samples, 2.25%) + + _.. + + + regex_automata::util::prefilter::Prefilter::new (1 samples, 1.12%) + + + + + regex_automata::util::prefilter::Choice::new (1 samples, 1.12%) + + + + + regex_automata::util::prefilter::teddy::Teddy::new (1 samples, 1.12%) + + + + + aho_corasick::dfa::Builder::build_from_noncontiguous (1 samples, 1.12%) + + + + + aho_corasick::dfa::Builder::finish_build_one_start::{{closure}} (1 samples, 1.12%) + + + + + regex_syntax::utf8::Utf8Sequence::as_slice (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + regex_automata::nfa::thompson::compiler::Utf8Compiler::new (2 samples, 2.25%) + + r.. + + + regex_automata::nfa::thompson::map::Utf8BoundedMap::clear (2 samples, 2.25%) + + r.. + + + <T as alloc::vec::spec_from_elem::SpecFromElem>::from_elem (2 samples, 2.25%) + + <.. + + + alloc::vec::Vec<T,A>::extend_with (2 samples, 2.25%) + + a.. + + + regex_automata::meta::regex::Builder::build (5 samples, 5.62%) + + regex_a.. + + + regex_automata::meta::strategy::new (5 samples, 5.62%) + + regex_a.. + + + regex_automata::nfa::thompson::compiler::Compiler::build_many_from_hir (4 samples, 4.49%) + + regex.. + + + <core::iter::adapters::map::Map<I,F> as core::iter::traits::iterator::Iterator>::next (4 samples, 4.49%) + + <core.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_alt_iter (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_cap (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c_at_least (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::compiler::Compiler::c (4 samples, 4.49%) + + regex.. + + + regex_automata::nfa::thompson::builder::Builder::patch (1 samples, 1.12%) + + + + + [unknown] (10 samples, 11.24%) + + [unknown] + + + _start (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (2 samples, 2.25%) + + [.. + + + [[kernel.kallsyms]] (3 samples, 3.37%) + + [[k.. + + + [[kernel.kallsyms]] (5 samples, 5.62%) + + [[kerne.. + + + [[kernel.kallsyms]] (5 samples, 5.62%) + + [[kerne.. + + + [[kernel.kallsyms]] (6 samples, 6.74%) + + [[kernel... + + + s4 (59 samples, 66.29%) + + s4 + + + [[kernel.kallsyms]] (24 samples, 26.97%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (24 samples, 26.97%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (24 samples, 26.97%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (24 samples, 26.97%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (24 samples, 26.97%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + [[kernel.kallsyms]] (1 samples, 1.12%) + + + + + all (89 samples, 100%) + + + + + perf-exec (23 samples, 25.84%) + + perf-exec + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + + [[kernel.kallsyms]] (23 samples, 25.84%) + + [[kernel.kallsyms]] + + +