3 files changed, 69 insertions, 61 deletions

diff --git a/src/solvers/intuitive.rs b/src/solvers/intuitive.rs
index b8d375a..3db1d33 100755
--- a/src/solvers/intuitive.rs
+++ b/src/solvers/intuitive.rs
@@ -52,8 +52,8 @@ impl NormalSolver {
     pub fn solve(&mut self) {
         for (n, i) in self.permutations.iter().enumerate() {
             let tmp: Vec<u32> = i.iter().map(|x| *x).collect();
-            //println!("perm {}: {:?}", n, tmp);
-            println!("perm {}: {:?}", n, self.masks[n]);
+            println!("perm {}: {:?}", n, tmp);
+            println!("perm {}: {:b}", n, self.masks[n]);
         }
         println!("calculate results");
         self.permute(
diff --git a/src/solvers/mod.rs b/src/solvers/mod.rs
index 6d26266..1bdc228 100755
--- a/src/solvers/mod.rs
+++ b/src/solvers/mod.rs
@@ -1,28 +1,5 @@
 //pub mod incremental_block;
 pub mod intuitive;
-#[cfg(feature = "gpu")]
-pub mod opencl;
+//#[cfg(feature = "gpu")]
 pub mod gpusolver;
-
-lazy_static! {
-    pub static ref PERMUTATIONS: (Vec<Vec<u32>>, Vec<u64>) = {
-        let n = crate::N;
-        let mut heap = (1..=n).collect::<Vec<u32>>();
-        let heap = permutohedron::Heap::new(&mut heap);
-        let n_f = permutohedron::factorial(n as usize);
-        let mut permutations = Vec::with_capacity(n_f);
-
-        let mut masks: Vec<u64> = vec![0; n_f];
-        println!("Generating permutations");
-        for (j, data) in heap.enumerate() {
-            let mut sum = 0;
-            permutations.push(data.clone());
-            for stone in data.iter().take(n as usize - 1) {
-                sum += stone;
-                masks[j] |= 1 << sum;
-            }
-        }
-        (permutations, masks)
-    };
-}
-
+pub mod opencl;
diff --git a/src/solvers/opencl.rs b/src/solvers/opencl.rs
index 25b8119..676c5cc 100644
--- a/src/solvers/opencl.rs
+++ b/src/solvers/opencl.rs
@@ -1,49 +1,80 @@
-use lazy_static::*;
-use ocl::ProQue;
-#[macro_use]
+use ocl::{Buffer, Context, Device, Platform, Queue};
+use std::sync::mpsc::{Receiver, Sender};
 
-lazy_static! {
-    static ref BUFFER: ocl::Buffer<u64> = {
+pub struct Job {
+    rows: Vec<u32>,
+    bitmask: u64,
+}
+
+pub struct GpuSolver {
+    platform: Platform,
+    device: Device,
+    context: Context,
+    queue: Queue,
+    n: u32,
+    h: u32,
+    w: u32,
+    permutations: Buffer<u64>,
+    rec_queues: Vec<Receiver<Job>>,
+}
+
+impl GpuSolver {
+    pub fn new(permutation_masks: &[u64], n: u32, h: u32, w: u32) -> ocl::Result<Vec<Sender<Job>>> {
         let platform = ocl::Platform::default();
-        let device = ocl::Device::first(platform).unwrap();
+        let device = ocl::Device::first(platform)?;
         let context = ocl::Context::builder()
             .platform(platform)
             .devices(device.clone())
-            .build()
-            .unwrap();
-        let queue = ocl::Queue::new(&context, device, None).unwrap();
+            .build()?;
+        let queue = ocl::Queue::new(&context, device, None)?;
 
-        println!("created buffer!");
-        ocl::Buffer::builder()
-            .queue(queue)
-            .copy_host_slice(crate::solvers::PERMUTATIONS.1.as_ref())
-            .len(crate::solvers::PERMUTATIONS.1.len())
-            .build()
-            .unwrap()
-    };
-    static ref QUEUE: ocl::ProQue = {
-        let src =
-            std::fs::read_to_string("src/solvers/check.cl").expect("failed to open kernel file");
-        ProQue::builder()
-            .src(src)
-            .dims(crate::solvers::PERMUTATIONS.0.len())
-            .build()
-            .unwrap()
-    };
-}
+        let buffer = ocl::Buffer::builder()
+            .queue(queue.clone())
+            .copy_host_slice(permutation_masks)
+            .len(permutation_masks.len())
+            .build()?;
 
-pub fn get_buffer() -> &'static ocl::Buffer<u64> {
-    &BUFFER
-}
+        let mut senders = Vec::with_capacity(h as usize);
+        let mut receivers = Vec::with_capacity(h as usize);
+        for _ in 0..h {
+            let (sx, rx) = std::sync::mpsc::channel();
+            senders.push(sx);
+            receivers.push(rx);
+        }
 
+        let solver = Self {
+            platform,
+            device,
+            context,
+            queue,
+            n,
+            h,
+            w,
+            permutations: buffer,
+            rec_queues: receivers,
+        };
+        std::thread::spawn(move || {
+            solver.run();
+        });
+        Ok(senders)
+    }
+
+    fn run(self) -> ! {
+        for rec in self.rec_queues.iter().cycle() {
+            //if rec.
+        }
+        loop {}
+    }
+}
+/*
 pub fn check(permutations: &[u64], w: u32, n: u32, mask: u64, offset: usize) -> ocl::Result<()> {
     //println!("read src!");
     let src = std::fs::read_to_string("src/solvers/check.cl").expect("failed to open kernel file");
 
     //println!("created queue!");
-    //println!("offset: {}", offset);
-    //println!("length: {}", permutations.len() - offset);
-    let pro_que = ProQue::builder()
+    println!("offset: {}", offset);
+    println!("length: {}", permutations.len() - offset);
+    let pro_que = ocl::ProQue::builder()
         .src(src)
         .dims(permutations.len() - offset)
         .build()?;
@@ -72,4 +103,4 @@ pub fn check(permutations: &[u64], w: u32, n: u32, mask: u64, offset: usize) ->
         println!("The resuts are now '{:?}'!", vec);
     }
     Ok(())
-}
+}*/