Vulkan, take 6

Author: dariost

wyvern-vulkan/examples/bfs.rs

@@ -1,4 +1,5 @@
 #![feature(nll)]
+#![allow(unused_imports)]
 
 extern crate wyvern_core as wcore;
 extern crate wyvern_vulkan as wvk;
@@ -15,23 +16,48 @@ fn main() {
     let program = builder.finalize().unwrap();
     let executor = VkExecutor::new(Default::default()).unwrap();
     let mut executable = executor.compile(program).unwrap();
-    let asd = executor.new_resource().unwrap();
-    let foo = executor.new_resource().unwrap();
-    let bar = executor.new_resource().unwrap();
-    foo.set_data(TokenValue::Scalar(ConstantScalar::U32(0)));
-    asd.set_data(TokenValue::Scalar(ConstantScalar::U32(2)));
-    bar.set_data(TokenValue::Scalar(ConstantScalar::U32(21)));
-    executable.bind("foo", IO::Output, foo.clone());
-    executable.bind("asd", IO::Input, asd.clone());
-    executable.bind("bar", IO::Input, asd.clone());
+    let in1 = executor.new_resource().unwrap();
+    let in2 = executor.new_resource().unwrap();
+    let out = executor.new_resource().unwrap();
+    in1.set_data(TokenValue::Vector(ConstantVector::U32(vec![2; 10000])));
+    in2.set_data(TokenValue::Scalar(ConstantScalar::U32(3)));
+    out.set_data(TokenValue::Scalar(ConstantScalar::U32(0)));
+    executable.bind("out", IO::Output, out.clone());
+    executable.bind("in1", IO::Input, in1.clone());
+    executable.bind("in2", IO::Input, in2.clone());
     executable.run().unwrap();
-    println!("{:?}", foo.get_data());
+    println!("{:?}", out.get_data());
 }
 
 fn program(builder: &ProgramBuilder) {
-    let x = Variable::new(builder).mark_as_input("asd").load();
-    let y = Variable::new(builder).mark_as_input("bar").load();
-    let a: Constant<u32> = y * x;
-    let b = Variable::new(builder).mark_as_output("foo");
-    b.store(a);
+    let zero = Constant::new(0_u32, builder);
+    let one = Constant::new(1_u32, builder);
+    let v: Array<u32> = Array::new(zero, 10000, true, builder).mark_as_input("in1");
+    let a: Constant<u32> = Variable::new(builder).mark_as_input("in2").load();
+    let o = Variable::new(builder).mark_as_output("out");
+    let id = builder.worker_id();
+    let size = builder.num_workers();
+    let tmp: Array<u32> = Array::new(size, 10000, true, builder);
+    let v_length = v.len();
+    let index = Variable::new(builder);
+    index.store(id);
+    builder.while_loop(|_| {
+        index.load().lt(v_length)
+    }, |_| {
+        let old_value = tmp.at(id).load();
+        tmp.at(id).store(old_value + v.at(index.load()).load() * a);
+        index.store(index.load() + size);
+    });
+    builder.memory_barrier();
+    builder.if_then(|_| {
+        id.eq(zero)
+    }, |_| {
+        index.store(zero);
+        builder.while_loop(|_| {
+            index.load().lt(size)
+        }, |_| {
+            o.store(o.load() + tmp.at(index.load()).load());
+            index.store(index.load() + one);
+        });
+    });
 }

wyvern-vulkan/examples/simple.rs

@@ -104,6 +104,7 @@ impl Executable for VkExecutable {
             if let Some(ref x) = self.assoc[i] {
                 buffers.push(x.get_handle().lock().unwrap().clone())
             } else if let BindType::Private(size, ty) = self.bindings[i].1 {
+                let size = size + 1;
                 match ty {
                     DataType::U32 => buffers.push(ResourceType::VU32(
                         CpuAccessibleBuffer::from_iter(
@@ -161,15 +162,15 @@ impl Executable for VkExecutable {
         });
         unsafe { set.write(&self.device, writer) };
         let sanitized_set = MyDescriptorSet {
-            set: set,
+            set,
             layout: self.layout.clone(),
-            buffers: buffers
+            buffers
         };
         let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(
             self.device.clone(),
             self.queue.family(),
         ).unwrap()
-            .dispatch([896, 1, 1], self.pipeline.clone(), sanitized_set, ())
+            .dispatch([1536, 1, 1], self.pipeline.clone(), sanitized_set, ())
             .unwrap()
             .build()
             .unwrap();
@@ -194,7 +195,6 @@ unsafe impl DescriptorSetDesc for MyDescriptorSet {
     }
 
     fn descriptor(&self, binding: usize) -> Option<DescriptorDesc> {
-        eprintln!("Binding: {:?}", binding);
         self.layout.descriptor(0, binding)
     }
 }
@@ -212,7 +212,6 @@ unsafe impl DescriptorSet for MyDescriptorSet {
         if index >= self.buffers.len() {
             return None;
         }
-        eprintln!("Index: {:?}", index);
         let desc_index = index as u32;
         match self.buffers[index] {
             ResourceType::U32(ref x) => Some((x, desc_index)),

wyvern-vulkan/src/executable.rs

@@ -82,6 +82,19 @@ impl Executor for VkExecutor {
 
     fn compile(&self, program: Program) -> Result<VkExecutable, String> {
         let (binary, bindings) = generate(&program, self.version)?;
+        fn u32tou8(v: &[u32]) -> Vec<u8> {
+            use byteorder::{ByteOrder, LittleEndian};
+            let mut result = Vec::new();
+            for i in v {
+                let mut buf = [0; 4];
+                LittleEndian::write_u32(&mut buf, *i);
+                for j in &buf {
+                    result.push(*j);
+                }
+            }
+            result
+        }
+        ::std::fs::write("dump.spv", u32tou8(&binary)).unwrap();
         // TODO: validate and optimize the binary
         let module = unsafe {
             ShaderModule::from_words(self.device.clone(), &binary).map_err(|x| format!("{:?}", x))?