Enable jitdump profiling support by default (#1310)

* Enable jitdump profiling support by default

This the result of some of the investigation I was doing for #1017. I've
done a number of refactorings here which culminated in a number of
changes that all amount to what I think should result in jitdump support being
enabled by default:

* Pass in a list of finished functions instead of just a range to
  ensure that we're emitting jit dump data for a specific module rather
  than a whole `CodeMemory` which may have other modules.
* Define `ProfilingStrategy` in the `wasmtime` crate to have everything
  locally-defined
* Add support to the C API to enable profiling
* Documentation added for profiling with jitdump to the book
* Split out supported/unsupported files in `jitdump.rs` to avoid having
  lots of `#[cfg]`.
* Make dependencies optional that are only used for `jitdump`.
* Move initialization up-front to `JitDumpAgent::new()` instead of
  deferring it to the first module.
* Pass around `Arc<dyn ProfilingAgent>` instead of
  `Option<Arc<Mutex<Box<dyn ProfilingAgent>>>>`

The `jitdump` Cargo feature is now enabled by default which means that
our published binaries, C API artifacts, and crates will support
profiling at runtime by default. The support I don't think is fully
fleshed out and working but I think it's probably in a good enough spot
we can get users playing around with it!

crates/api/Cargo.toml

@@ -40,13 +40,16 @@ tempfile = "3.1"
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ['wat']
+default = ['wat', 'jitdump']
 
 # Enables experimental support for the lightbeam codegen backend, an alternative
 # to cranelift. Requires Nightly Rust currently, and this is not enabled by
 # default.
 lightbeam = ["wasmtime-jit/lightbeam"]
 
+# Enables support for the `perf` jitdump profiler
+jitdump = ["wasmtime-jit/jitdump"]
+
 [[test]]
 name = "host-segfault"
 harness = false

crates/api/src/lib.rs

@@ -26,7 +26,7 @@ pub use crate::func::*;
 pub use crate::instance::Instance;
 pub use crate::module::Module;
 pub use crate::r#ref::{AnyRef, HostInfo, HostRef};
-pub use crate::runtime::{Config, Engine, OptLevel, Store, Strategy};
+pub use crate::runtime::*;
 pub use crate::trap::Trap;
 pub use crate::types::*;
 pub use crate::values::*;

crates/api/src/module.rs

@@ -367,7 +367,7 @@ impl Module {
             &mut store.compiler_mut(),
             binary,
             store.engine().config().debug_info,
-            store.engine().config().profiler.as_ref(),
+            &*store.engine().config().profiler,
         )?;
 
         Ok(Module {

crates/api/src/runtime.rs

@@ -3,12 +3,12 @@ use std::cell::RefCell;
 use std::fmt;
 use std::path::Path;
 use std::rc::Rc;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use wasmparser::{OperatorValidatorConfig, ValidatingParserConfig};
 use wasmtime_environ::settings::{self, Configurable};
 use wasmtime_environ::CacheConfig;
 use wasmtime_jit::{native, CompilationStrategy, Compiler};
-use wasmtime_profiling::{JitDumpAgent, ProfilingAgent, ProfilingStrategy};
+use wasmtime_profiling::{JitDumpAgent, NullProfilerAgent, ProfilingAgent};
 
 // Runtime Environment
 
@@ -26,7 +26,7 @@ pub struct Config {
     pub(crate) debug_info: bool,
     pub(crate) strategy: CompilationStrategy,
     pub(crate) cache_config: CacheConfig,
-    pub(crate) profiler: Option<Arc<Mutex<Box<dyn ProfilingAgent + Send>>>>,
+    pub(crate) profiler: Arc<dyn ProfilingAgent>,
 }
 
 impl Config {
@@ -65,7 +65,7 @@ impl Config {
             flags,
             strategy: CompilationStrategy::Auto,
             cache_config: CacheConfig::new_cache_disabled(),
-            profiler: None,
+            profiler: Arc::new(NullProfilerAgent),
         }
     }
 
@@ -225,11 +225,9 @@ impl Config {
     /// Profiler creation calls the type's default initializer where the purpose is
     /// really just to put in place the type used for profiling.
     pub fn profiler(&mut self, profile: ProfilingStrategy) -> Result<&mut Self> {
-        match profile {
-            ProfilingStrategy::JitDumpProfiler => {
-                self.profiler = { Some(Arc::new(Mutex::new(Box::new(JitDumpAgent::default())))) }
-            }
-            _ => self.profiler = { None },
+        self.profiler = match profile {
+            ProfilingStrategy::JitDump => Arc::new(JitDumpAgent::new()?) as Arc<dyn ProfilingAgent>,
+            ProfilingStrategy::None => Arc::new(NullProfilerAgent),
         };
         Ok(self)
     }
@@ -381,6 +379,17 @@ pub enum OptLevel {
     SpeedAndSize,
 }
 
+/// Select which profiling technique to support.
+#[derive(Debug, Clone, Copy)]
+pub enum ProfilingStrategy {
+    /// No profiler support.
+    None,
+
+    /// Collect profiling info for "jitdump" file format, used with `perf` on
+    /// Linux.
+    JitDump,
+}
+
 // Engine
 
 /// An `Engine` which is a global context for compilation and management of wasm