Merge #2262

2262: Make parallelism optional for singlepass backend r=syrusakbary a=matklad

# Description

closes #2261

# Review

- [ ] Add a short description of the change to the CHANGELOG.md file


Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

lib/compiler-singlepass/Cargo.toml

@@ -15,7 +15,7 @@ edition = "2018"
 wasmer-compiler = { path = "../compiler", version = "1.0.2", features = ["translator"], default-features = false }
 wasmer-vm = { path = "../vm", version = "1.0.2" }
 wasmer-types = { path = "../types", version = "1.0.2", default-features = false, features = ["std"] }
-rayon = "1.5"
+rayon = { version = "1.5", optional = true }
 hashbrown = { version = "0.9", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 more-asserts = "0.2"
@@ -33,7 +33,7 @@ target-lexicon = { version = "0.11", default-features = false }
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ["std", "enable-serde"]
+default = ["std", "enable-serde", "rayon"]
 enable-serde = ["wasmer-compiler/enable-serde", "wasmer-types/enable-serde"]
 std = ["wasmer-compiler/std", "wasmer-types/std"]
 core = ["hashbrown"]

lib/compiler-singlepass/src/compiler.rs

@@ -8,7 +8,8 @@ use crate::codegen_x64::{
 };
 use crate::config::Singlepass;
 use loupe::MemoryUsage;
-use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+#[cfg(feature = "rayon")]
+use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 use std::sync::Arc;
 use wasmer_compiler::TrapInformation;
 use wasmer_compiler::{
@@ -71,7 +72,7 @@ impl Compiler for SinglepassCompiler {
         let import_trampolines: PrimaryMap<SectionIndex, _> = (0..module.num_imported_functions)
             .map(FunctionIndex::new)
             .collect::<Vec<_>>()
-            .into_par_iter()
+            .into_par_iter_if_rayon()
             .map(|i| {
                 gen_import_call_trampoline(&vmoffsets, i, &module.signatures[module.functions[i]])
             })
@@ -81,12 +82,12 @@ impl Compiler for SinglepassCompiler {
         let functions = function_body_inputs
             .iter()
             .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
-            .par_iter()
+            .into_par_iter_if_rayon()
             .map(|(i, input)| {
                 let middleware_chain = self
                     .config
                     .middlewares
-                    .generate_function_middleware_chain(*i);
+                    .generate_function_middleware_chain(i);
                 let mut reader =
                     MiddlewareBinaryReader::new_with_offset(input.data, input.module_offset);
                 reader.set_middleware_chain(middleware_chain);
@@ -107,7 +108,7 @@ impl Compiler for SinglepassCompiler {
                     &vmoffsets,
                     &memory_styles,
                     &table_styles,
-                    *i,
+                    i,
                     &locals,
                 )
                 .map_err(to_compile_error)?;
@@ -128,8 +129,7 @@ impl Compiler for SinglepassCompiler {
             .signatures
             .values()
             .collect::<Vec<_>>()
-            .par_iter()
-            .cloned()
+            .into_par_iter_if_rayon()
             .map(gen_std_trampoline)
             .collect::<Vec<_>>()
             .into_iter()
@@ -138,7 +138,7 @@ impl Compiler for SinglepassCompiler {
         let dynamic_function_trampolines = module
             .imported_function_types()
             .collect::<Vec<_>>()
-            .par_iter()
+            .into_par_iter_if_rayon()
             .map(|func_type| gen_std_dynamic_import_trampoline(&vmoffsets, &func_type))
             .collect::<Vec<_>>()
             .into_iter()
@@ -168,6 +168,25 @@ fn to_compile_error<T: ToCompileError>(x: T) -> CompileError {
     x.to_compile_error()
 }
 
+trait IntoParIterIfRayon {
+    type Output;
+    fn into_par_iter_if_rayon(self) -> Self::Output;
+}
+
+impl<T: Send> IntoParIterIfRayon for Vec<T> {
+    #[cfg(not(feature = "rayon"))]
+    type Output = std::vec::IntoIter<T>;
+    #[cfg(feature = "rayon")]
+    type Output = rayon::vec::IntoIter<T>;
+
+    fn into_par_iter_if_rayon(self) -> Self::Output {
+        #[cfg(not(feature = "rayon"))]
+        return self.into_iter();
+        #[cfg(feature = "rayon")]
+        return self.into_par_iter();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;