build.rs scripts now parallelize with rayon (not sure of tradeoff)

Author: lilith

Cargo.lock

@@ -26,6 +26,6 @@ base64="0.22"
 imageflow_helpers = { path = "../imageflow_helpers", version = "*"}
 cbindgen = "0.28"
 regex-lite = { version = "0.1.6" }
-
+rayon = "1"
 [features]
 nightly = ["imageflow_core/nightly", "imageflow_helpers/nightly"]

imageflow_abi/Cargo.toml

@@ -1,4 +1,3 @@
-
 extern crate cbindgen;
 extern crate regex_lite;
 extern crate imageflow_helpers;
@@ -10,6 +9,7 @@ use std::path;
 use cbindgen::Builder;
 use std::io::Cursor;
 use std::env;
+use rayon::prelude::*;
 
 
 static OPAQUE_STRUCTS: &'static str = r#"
@@ -310,56 +310,29 @@ fn main() {
     //let base = "imageflow_"; //for debugging more easily
     let base = "../bindings/headers/imageflow_";
 
-    build(format!("{}default.h",base), Target::Default);
-
-    build(format!("{}lua.h",base), Target::Lua);
-    build(format!("{}raw.h",base), Target::Raw);
-
-    build(format!("{}short.h",base), Target::SignaturesOnly);
-    build(format!("{}pinvoke.h",base), Target::PInvoke);
-
-    // build(format!("{}SCREAMING_SNAKE.h",base), Target::PrefixAll{
-    //     prefix: "Imageflow",
-    //     struct_name: Style::ScreamingSnake,
-    //     enum_name: Style::ScreamingSnake,
-    //     enum_member: Style::ScreamingSnake,
-    // });
-    build(format!("{}SCREAMING_ENUMS.h",base), Target::PrefixAll{
-        prefix: "Imageflow",
-        struct_name: Style::Snake,
-        enum_name: Style::ScreamingSnake,
-        enum_member: Style::ScreamingSnake,
-    });
-    // build(format!("{}PascalCase.h",base), Target::PrefixAll{
-    //     prefix: "",
-    //     struct_name: Style::PascalCase,
-    //     enum_name: Style::PascalCase,
-    //     enum_member: Style::PascalCase,
-    // });
-    build(format!("{}PrefixedPascalCase.h",base), Target::PrefixAll{
-        prefix: "Imageflow",
-        struct_name: Style::PascalCase,
-        enum_name: Style::PascalCase,
-        enum_member: Style::PascalCase,
+    // Create a vector of tuples containing (filename, target)
+    let builds = vec![
+        (format!("{}default.h", base), Target::Default),
+        (format!("{}lua.h", base), Target::Lua),
+        (format!("{}raw.h", base), Target::Raw),
+        (format!("{}short.h", base), Target::SignaturesOnly),
+        (format!("{}pinvoke.h", base), Target::PInvoke),
+        (format!("{}SCREAMING_ENUMS.h", base), Target::PrefixAll{
+            prefix: "Imageflow",
+            struct_name: Style::Snake,
+            enum_name: Style::ScreamingSnake,
+            enum_member: Style::ScreamingSnake,
+        }),
+        (format!("{}PrefixedPascalCase.h", base), Target::PrefixAll{
+            prefix: "Imageflow",
+            struct_name: Style::PascalCase,
+            enum_name: Style::PascalCase,
+            enum_member: Style::PascalCase,
+        }),
+    ];
+
+    // Use rayon to parallelize the builds
+    builds.par_iter().for_each(|(file, target)| {
+        build(file.clone(), *target);
     });
-    // build(format!("{}Prefixed_Pascal_Snake.h",base), Target::PrefixAll{
-    //     prefix: "Imageflow",
-    //     struct_name: Style::PascalSnake,
-    //     enum_name: Style::PascalSnake,
-    //     enum_member: Style::PascalSnake,
-    // });
-
-    // build(format!("{}prefixed_Camel_Snake.h",base), Target::PrefixAll{
-    //     prefix: "Imageflow",
-    //     struct_name: Style::CamelSnake,
-    //     enum_name: Style::CamelSnake,
-    //     enum_member: Style::CamelSnake,
-    // });
-    // build(format!("{}prefixedCamelCase.h",base), Target::PrefixAll{
-    //     prefix: "Imageflow",
-    //     struct_name: Style::CamelCase,
-    //     enum_name: Style::CamelCase,
-    //     enum_member: Style::CamelCase,
-    // });
-
 }

imageflow_abi/build.rs

@@ -24,6 +24,7 @@ rgb = "0.8"
 [build-dependencies]
 quick-error = "2"
 chrono = "0.4"
+rayon = "1"
 
 [features]
 nightly = ["imageflow_helpers/nightly"]

imageflow_types/Cargo.toml

@@ -10,6 +10,8 @@ use std::path::{Path};
 use std::process::{Command, Output};
 use std::collections::HashMap;
 use std::time::{Instant};
+extern crate rayon;
+use rayon::prelude::*;
 
 quick_error! {
     #[derive(Debug)]
@@ -124,30 +126,31 @@ fn env_or_cmd(key: &str, cmd: &str) -> Option<String>{
 //    Path::new(&build_rs_path).parent().expect("Rust must be stripping parent directory info from file! macro. This breaks path stuff in build.rs.").to_owned()
 //}
 
-fn collect_info(shopping_list: Vec<EnvTidbit>) -> HashMap<String, Option<String>>{
-
-    let mut info = HashMap::new();
-    for from in shopping_list {
-        let (k,v) = match from {
-            EnvTidbit::Env(key) => (key, fetch_env(key, false, true)),
-            EnvTidbit::EnvReq(key) => (key, fetch_env(key, true, true)),
-            EnvTidbit::FileContentsReq{key, relative_to_build_rs} => {
-
-                let io_error_expect = format!("Failed to read file {:?}. This file is required to be embedded in output binaries.", relative_to_build_rs);
-                let mut file = File::open(relative_to_build_rs).expect(&io_error_expect);
-                let mut contents = String::new();
-                file.read_to_string( &mut contents).expect(&io_error_expect);
-                (key, Some(contents))
-            },
-            EnvTidbit::Cmd{key, cmd} => (key, command(key, cmd, false, false)),
-            EnvTidbit::CmdReq{key, cmd} => (key, command(key, cmd, true, false)),
-            EnvTidbit::CmdOrEnvReq{key, cmd} => (key, command(key, cmd, true, true)),
-            EnvTidbit::CmdOrEnv{key, cmd} => (key, command(key, cmd, false, true)),
-            EnvTidbit::EnvOrCmdInconsistent{key, cmd} => (key, env_or_cmd(key, cmd)),
-        };
-        info.insert(k.to_owned(),v);
-    }
-    info
+fn collect_info(shopping_list: Vec<EnvTidbit>) -> HashMap<String, Option<String>> {
+    let results: Vec<(String, Option<String>)> = shopping_list
+        .into_par_iter()
+        .map(|from| {
+            let (k, v) = match from {
+                EnvTidbit::Env(key) => (key, fetch_env(key, false, true)),
+                EnvTidbit::EnvReq(key) => (key, fetch_env(key, true, true)),
+                EnvTidbit::FileContentsReq { key, relative_to_build_rs } => {
+                    let io_error_expect = format!("Failed to read file {:?}. This file is required to be embedded in output binaries.", relative_to_build_rs);
+                    let mut file = File::open(relative_to_build_rs).expect(&io_error_expect);
+                    let mut contents = String::new();
+                    file.read_to_string(&mut contents).expect(&io_error_expect);
+                    (key, Some(contents))
+                },
+                EnvTidbit::Cmd { key, cmd } => (key, command(key, cmd, false, false)),
+                EnvTidbit::CmdReq { key, cmd } => (key, command(key, cmd, true, false)),
+                EnvTidbit::CmdOrEnvReq { key, cmd } => (key, command(key, cmd, true, true)),
+                EnvTidbit::CmdOrEnv { key, cmd } => (key, command(key, cmd, false, true)),
+                EnvTidbit::EnvOrCmdInconsistent { key, cmd } => (key, env_or_cmd(key, cmd)),
+            };
+            (k.to_owned(), v)
+        })
+        .collect();
+
+    results.into_iter().collect()
 }
 fn what_to_collect() -> Vec<EnvTidbit>{
     let mut c = Vec::new();