bench: backends

Author: kvark

benches/criterion.rs

@@ -39,7 +39,7 @@ fn parse_glsl(stage: naga::ShaderStage, inputs: &[Box<[u8]>]) {
 
 fn frontends(c: &mut Criterion) {
     let mut group = c.benchmark_group("front");
-    #[cfg(all(feature = "serialize", feature = "deserialize"))]
+    #[cfg(all(feature = "wgsl-in", feature = "serialize", feature = "deserialize"))]
     group.bench_function("bin", |b| {
         let inputs_wgsl = gather_inputs("tests/in", "wgsl");
         let mut parser = naga::front::wgsl::Parser::new();
@@ -93,22 +93,25 @@ fn frontends(c: &mut Criterion) {
     });
 }
 
-fn validation(c: &mut Criterion) {
-    #[cfg(feature = "wgsl-in")]
-    let inputs = {
-        let inputs_wgsl = gather_inputs("tests/in", "wgsl");
-        let mut parser = naga::front::wgsl::Parser::new();
-        inputs_wgsl
-            .iter()
-            .map(|input| {
-                let string = std::str::from_utf8(input).unwrap();
-                parser.parse(string).unwrap()
-            })
-            .collect::<Vec<_>>()
-    };
-    #[cfg(not(feature = "wgsl-in"))]
-    let inputs: Vec<Box<[u8]>> = Vec::new();
+#[cfg(feature = "wgsl-in")]
+fn gather_modules() -> Vec<naga::Module> {
+    let inputs = gather_inputs("tests/in", "wgsl");
+    let mut parser = naga::front::wgsl::Parser::new();
+    inputs
+        .iter()
+        .map(|input| {
+            let string = std::str::from_utf8(input).unwrap();
+            parser.parse(string).unwrap()
+        })
+        .collect()
+}
+#[cfg(not(feature = "wgsl-in"))]
+fn gather_modules() -> Vec<naga::Module> {
+    Vec::new()
+}
 
+fn validation(c: &mut Criterion) {
+    let inputs = gather_modules();
     let mut group = c.benchmark_group("valid");
     #[cfg(feature = "validate")]
     group.bench_function("safe", |b| {
@@ -136,7 +139,133 @@ fn validation(c: &mut Criterion) {
     });
 }
 
-fn backends(_c: &mut Criterion) {}
+fn backends(c: &mut Criterion) {
+    #[cfg(feature = "validate")]
+    let inputs = {
+        let mut validator = naga::valid::Validator::new(
+            naga::valid::ValidationFlags::empty(),
+            naga::valid::Capabilities::empty(),
+        );
+        let input_modules = gather_modules();
+        input_modules
+            .into_iter()
+            .flat_map(|module| validator.validate(&module).ok().map(|info| (module, info)))
+            .collect::<Vec<_>>()
+    };
+    #[cfg(not(feature = "validate"))]
+    let inputs = Vec::<(naga::Module, naga::valid::ModuleInfo)>::new();
+
+    let mut group = c.benchmark_group("back");
+    #[cfg(feature = "wgsl-out")]
+    group.bench_function("wgsl", |b| {
+        b.iter(|| {
+            let mut string = String::new();
+            let flags = naga::back::wgsl::WriterFlags::empty();
+            for &(ref module, ref info) in inputs.iter() {
+                let mut writer = naga::back::wgsl::Writer::new(&mut string, flags);
+                writer.write(module, info).unwrap();
+                string.clear();
+            }
+        });
+    });
+
+    #[cfg(feature = "spv-out")]
+    group.bench_function("spv", |b| {
+        b.iter(|| {
+            let mut data = Vec::new();
+            let options = naga::back::spv::Options::default();
+            for &(ref module, ref info) in inputs.iter() {
+                let mut writer = naga::back::spv::Writer::new(&options).unwrap();
+                writer.write(module, info, None, &mut data).unwrap();
+                data.clear();
+            }
+        });
+    });
+    #[cfg(feature = "spv-out")]
+    group.bench_function("spv-separate", |b| {
+        b.iter(|| {
+            let mut data = Vec::new();
+            let options = naga::back::spv::Options::default();
+            for &(ref module, ref info) in inputs.iter() {
+                let mut writer = naga::back::spv::Writer::new(&options).unwrap();
+                for ep in module.entry_points.iter() {
+                    let pipeline_options = naga::back::spv::PipelineOptions {
+                        shader_stage: ep.stage,
+                        entry_point: ep.name.clone(),
+                    };
+                    writer
+                        .write(module, info, Some(&pipeline_options), &mut data)
+                        .unwrap();
+                    data.clear();
+                }
+            }
+        });
+    });
+
+    #[cfg(feature = "msl-out")]
+    group.bench_function("msl", |b| {
+        b.iter(|| {
+            let mut string = String::new();
+            let options = naga::back::msl::Options::default();
+            for &(ref module, ref info) in inputs.iter() {
+                let pipeline_options = naga::back::msl::PipelineOptions::default();
+                let mut writer = naga::back::msl::Writer::new(&mut string);
+                writer
+                    .write(module, info, &options, &pipeline_options)
+                    .unwrap();
+                string.clear();
+            }
+        });
+    });
+
+    #[cfg(feature = "hlsl-out")]
+    group.bench_function("hlsl", |b| {
+        b.iter(|| {
+            let options = naga::back::hlsl::Options::default();
+            let mut string = String::new();
+            for &(ref module, ref info) in inputs.iter() {
+                let mut writer = naga::back::hlsl::Writer::new(&mut string, &options);
+                let _ = writer.write(module, info); // may fail on unimplemented things
+                string.clear();
+            }
+        });
+    });
+
+    #[cfg(feature = "glsl-out")]
+    group.bench_function("glsl-separate", |b| {
+        b.iter(|| {
+            let mut string = String::new();
+            let options = naga::back::glsl::Options {
+                version: naga::back::glsl::Version::Embedded(320),
+                writer_flags: naga::back::glsl::WriterFlags::empty(),
+                binding_map: Default::default(),
+            };
+            for &(ref module, ref info) in inputs.iter() {
+                for ep in module.entry_points.iter() {
+                    let pipeline_options = naga::back::glsl::PipelineOptions {
+                        shader_stage: ep.stage,
+                        entry_point: ep.name.clone(),
+                    };
+                    match naga::back::glsl::Writer::new(
+                        &mut string,
+                        module,
+                        info,
+                        &options,
+                        &pipeline_options,
+                    ) {
+                        Ok(mut writer) => {
+                            let _ = writer.write(); // can error if unsupported
+                        }
+                        Err(_) => {
+                            // missing features
+                        }
+                    };
+                    string.clear();
+                }
+            }
+        });
+    });
+}
 
 criterion_group!(criterion, frontends, validation, backends,);
 criterion_main!(criterion);