Add the pooling-allocator feature.

.github/workflows/main.yml

@@ -136,6 +136,7 @@ jobs:
     - run: cargo check -p wasmtime --no-default-features --features cache
     - run: cargo check -p wasmtime --no-default-features --features async
     - run: cargo check -p wasmtime --no-default-features --features uffd
+    - run: cargo check -p wasmtime --no-default-features --features pooling-allocator
     - run: cargo check -p wasmtime --no-default-features --features cranelift
     - run: cargo check -p wasmtime --no-default-features --features cranelift,wat,async,cache
 

crates/runtime/Cargo.toml

@@ -49,8 +49,11 @@ default = []
 
 async = ["wasmtime-fiber"]
 
+# Enables support for the pooling instance allocator
+pooling-allocator = []
+
 # Enables support for userfaultfd in the pooling allocator when building on Linux
-uffd = ["userfaultfd"]
+uffd = ["userfaultfd", "pooling-allocator"]
 
 # Enables trap handling using POSIX signals instead of Mach exceptions on MacOS.
 # It is useful for applications that do not bind their own exception ports and

crates/runtime/src/instance/allocator.rs

@@ -23,8 +23,10 @@ use wasmtime_environ::{
     SignatureIndex, TableInitializer, TrapCode, VMOffsets, WasmType, WASM_PAGE_SIZE,
 };
 
+#[cfg(feature = "pooling-allocator")]
 mod pooling;
 
+#[cfg(feature = "pooling-allocator")]
 pub use self::pooling::{
     InstanceLimits, ModuleLimits, PoolingAllocationStrategy, PoolingInstanceAllocator,
 };

crates/runtime/src/lib.rs

@@ -40,9 +40,12 @@ pub use crate::export::*;
 pub use crate::externref::*;
 pub use crate::imports::Imports;
 pub use crate::instance::{
-    InstanceAllocationRequest, InstanceAllocator, InstanceHandle, InstanceLimits,
-    InstantiationError, LinkError, ModuleLimits, OnDemandInstanceAllocator,
-    PoolingAllocationStrategy, PoolingInstanceAllocator, StorePtr,
+    InstanceAllocationRequest, InstanceAllocator, InstanceHandle, InstantiationError, LinkError,
+    OnDemandInstanceAllocator, StorePtr,
+};
+#[cfg(feature = "pooling-allocator")]
+pub use crate::instance::{
+    InstanceLimits, ModuleLimits, PoolingAllocationStrategy, PoolingInstanceAllocator,
 };
 pub use crate::jit_int::GdbJitImageRegistration;
 pub use crate::memory::{Memory, RuntimeLinearMemory, RuntimeMemoryCreator};

crates/runtime/src/memory.rs

@@ -364,6 +364,7 @@ impl Memory {
     }
 
     /// Returns whether or not the underlying storage of the memory is "static".
+    #[cfg(feature = "pooling-allocator")]
     pub(crate) fn is_static(&self) -> bool {
         if let Memory::Static { .. } = self {
             true

crates/runtime/src/table.rs

@@ -186,6 +186,7 @@ impl Table {
     }
 
     /// Returns whether or not the underlying storage of the table is "static".
+    #[cfg(feature = "pooling-allocator")]
     pub(crate) fn is_static(&self) -> bool {
         if let Table::Static { .. } = self {
             true

crates/wasmtime/Cargo.toml

@@ -52,7 +52,7 @@ wasi-cap-std-sync = { path = "../wasi-common/cap-std-sync" }
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ['async', 'cache', 'wat', 'jitdump', 'parallel-compilation', 'cranelift']
+default = ['async', 'cache', 'wat', 'jitdump', 'parallel-compilation', 'cranelift', 'pooling-allocator']
 
 # An on-by-default feature enabling runtime compilation of WebAssembly modules
 # with the Cranelift compiler. Cranelift is the default compilation backend of
@@ -76,8 +76,11 @@ cache = ["wasmtime-cache"]
 # `async fn` and calling functions asynchronously.
 async = ["wasmtime-fiber", "wasmtime-runtime/async", "async-trait"]
 
+# Enables support for the pooling instance allocation strategy
+pooling-allocator = ["wasmtime-runtime/pooling-allocator"]
+
 # Enables userfaultfd support in the runtime's pooling allocator when building on Linux
-uffd = ["wasmtime-runtime/uffd"]
+uffd = ["wasmtime-runtime/uffd", "pooling-allocator"]
 
 # Enables support for all architectures in Cranelift, allowing
 # cross-compilation using the `wasmtime` crate's API, notably the