From c36035c0667fdd224da914b50c30a9366e1a5c38 Mon Sep 17 00:00:00 2001
From: Dennis Kobert <dennis@kobert.dev>
Date: Tue, 7 Jan 2020 03:12:55 +0100
Subject: Fix global worgsize calculation

---
 src/solvers/intuitive.rs | 83 ++++++++++++++++++------------------------------
 1 file changed, 31 insertions(+), 52 deletions(-)

(limited to 'src/solvers/intuitive.rs')

diff --git a/src/solvers/intuitive.rs b/src/solvers/intuitive.rs
index 3db1d33..bb23a39 100755
--- a/src/solvers/intuitive.rs
+++ b/src/solvers/intuitive.rs
@@ -13,6 +13,7 @@ pub struct NormalSolver {
     /// Use to store already used blocks as a bitmask
     permutations: Vec<Vec<u32>>,
     masks: Vec<u64>,
+    senders: Vec<std::sync::mpsc::Sender<super::opencl::Job>>,
 }
 
 static mut TRIES: u32 = 0;
@@ -38,6 +39,12 @@ impl NormalSolver {
                 masks[j] |= 1 << sum;
             }
         }
+
+        let src =
+            std::fs::read_to_string("src/solvers/check.cl").expect("failed to open kernel file");
+
+        let senders =
+            super::opencl::GpuSolver::launch_sevice(&masks, n, h, w, 0, src.as_ref()).unwrap();
         Self {
             n,
             h,
@@ -46,14 +53,15 @@ impl NormalSolver {
             mask: (1 << w) - 2,
             permutations,
             masks,
+            senders,
         }
     }
 
     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 {}: {:b}", n, self.masks[n]);
+            //println!("perm {}: {:?}", n, tmp);
+            //println!("perm {}: {:b}", n, self.masks[n]);
         }
         println!("calculate results");
         self.permute(
@@ -66,58 +74,29 @@ impl NormalSolver {
             .as_ref(),
         );
         unsafe { println!("tries: {}\nsolutions: {}", TRIES, SOLUTIONS) }
+        loop {
+            std::thread::sleep(std::time::Duration::from_secs(5));
+        }
     }
 
     fn permute(&self, up: usize, index: usize, curr_mask: u64, numbers: &[u32]) {
-        if index as usize == numbers.len() {
-            //println!("checking {:?}", numbers);
-            unsafe {
-                TRIES += 1;
-            }
-            let mut tmask: u64 = 0;
-            let mut sum = 0;
-            let mut stones = 0;
-            for i in 1..=(self.w + 1) {
-                if curr_mask & (1 << i) == 0 {
-                    stones += 1;
-                    tmask |= 1 << (i - sum);
-                    sum = i;
-                }
-            }
-            if tmask == (1 << (self.n + 1)) - 2 && stones == self.n {
-                println!("tmask: {:b}", tmask);
-                println!("curr: {:b}", curr_mask);
-                //println!("success");
-                unsafe {
-                    SOLUTIONS += 1;
-                }
-                for i in numbers {
-                    println!("{}\t{}", numbers[0], i);
-                }
-            }
-            return;
-        }
         let mut new_num = Vec::from(numbers);
         let start = numbers[index as usize] / self.chunk;
         if index as usize == numbers.len() - 1 {
-            #[cfg(feature = "gpu")]
-            {
-                crate::solvers::opencl::check(
-                    self.masks.as_ref(),
-                    self.w,
-                    self.n,
-                    curr_mask,
-                    (start * self.chunk) as usize,
-                )
+            //#[cfg(feature = "gpu")]
+            //{
+            let i = self.n - 2 - numbers[index] / self.chunk;
+            self.senders[i as usize]
+                .send(super::opencl::Job::new(new_num, curr_mask))
                 .unwrap();
-                return;
-            }
+            return;
+            //}
         }
         for i in start..self.n - (self.h - 1 - index as u32) {
             for n in 1..(numbers.len() - index) {
                 new_num[n + index] = (n as u32 + i) * self.chunk;
             }
-            if index == 0 && false {
+            /*if index == 0 {
                 (0..self.chunk).into_par_iter().for_each(|j| {
                     let mut new_num = new_num.clone();
                     let tmp = i * self.chunk + j;
@@ -129,17 +108,17 @@ impl NormalSolver {
                         &new_num,
                     );
                 });
-            } else {
-                for j in 0..self.chunk {
-                    new_num[index] = i * self.chunk + j;
-                    self.permute(
-                        up,
-                        index + 1,
-                        curr_mask | self.masks[new_num[index] as usize],
-                        &new_num,
-                    );
-                }
+            } else {*/
+            for j in 0..self.chunk {
+                new_num[index] = i * self.chunk + j;
+                self.permute(
+                    up,
+                    index + 1,
+                    curr_mask | self.masks[new_num[index] as usize],
+                    &new_num,
+                );
             }
+            //}
         }
     }
 }
-- 
cgit v1.2.3-70-g09d2