1 files changed, 19 insertions, 24 deletions

diff --git a/src/solvers/gpu/host.rs b/src/solvers/gpu/host.rs
index 4fe835a..6b91d74 100644
--- a/src/solvers/gpu/host.rs
+++ b/src/solvers/gpu/host.rs
@@ -1,4 +1,4 @@
-use super::{Message, ResultMessage};
+use super::{GpuError, Message, ResultMessage};
 use ocl::{flags, Buffer, Context, Device, Kernel, Platform, Program, Queue};
 use std::sync::mpsc::{channel, Receiver, Sender};
 
@@ -70,7 +70,9 @@ impl Host {
         let handle = std::thread::Builder::new()
             .name("GPU Host Deamon".into())
             .spawn(move || {
-                solver.run();
+                if let Err(err) = solver.run() {
+                    println!("{}", err);
+                }
             })
             .unwrap();
         println!("started gpu thread");
@@ -84,11 +86,10 @@ impl Host {
     }
     fn get_off(&self, queue: usize) -> usize {
         let chunk = self.permutations.len() / self.n as usize;
-        let off = self.permutations.len() - chunk - self.get_dim(queue);
-        if off > isize::max_value() as usize {
-            panic!("workgroup size to big, offset underflow")
+        if self.permutations.len() < chunk + self.get_dim(queue) {
+            panic!("workgroup size too big; offset underflow")
         }
-        off
+        self.permutations.len() - chunk - self.get_dim(queue)
     }
     fn get_res(&self, queue: usize) -> usize {
         let dim = self.get_dim(queue);
@@ -98,7 +99,7 @@ impl Host {
         (self.wg_size + 63) / 64
     }
 
-    fn run(self) {
+    fn run(self) -> Result<(), GpuError> {
         let queues = (self.n - self.h + 1) as usize;
         let mut instruction_buffer = Vec::with_capacity((self.n - self.h) as usize);
         let mut result_buffer = Vec::with_capacity((self.n - self.h) as usize);
@@ -108,27 +109,25 @@ impl Host {
                 .queue(self.queue.clone())
                 .len(self.wg_size)
                 .flags(flags::MEM_READ_WRITE)
-                .build()
-                .unwrap();
+                .build()?;
 
             instruction_buffer.push(buffer);
             let results: Buffer<u64> = Buffer::builder()
                 .queue(self.queue.clone())
                 .len(self.get_res(i))
                 .flags(flags::MEM_READ_WRITE)
-                .build()
-                .unwrap();
+                .build()?;
             result_buffer.push(results);
         }
         println!("finished gpu setup");
         loop {
-            match self.receiver.recv().expect("Channel to Host broke") {
+            match self.receiver.recv()? {
                 Message::CpuDone => {
-                    self.output_sender.send(Message::CpuDone);
-                    return;
+                    self.output_sender.send(Message::CpuDone)?;
+                    return Ok(());
                 }
                 Message::Terminate => {
-                    return;
+                    return Ok(());
                 }
                 Message::HostMessage((id, i, buffer)) => {
                     let i = i as usize;
@@ -137,7 +136,7 @@ impl Host {
                     let res = self.get_res(i);
                     let res_size = self.get_res_save_dim();
 
-                    instruction_buffer[i].write(&buffer).enq().unwrap();
+                    instruction_buffer[i].write(&buffer).enq()?;
 
                     //println!("dim: {}", dim);
                     //println!("off: {}", self.get_off(i));
@@ -154,8 +153,7 @@ impl Host {
                         .arg(self.n)
                         .arg(self.w)
                         .arg(off)
-                        .build()
-                        .unwrap();
+                        .build()?;
 
                     unsafe {
                         kernel
@@ -164,8 +162,7 @@ impl Host {
                             .global_work_offset(kernel.default_global_work_offset())
                             .global_work_size(dim)
                             .local_work_size(self.wg_size)
-                            .enq()
-                            .unwrap();
+                            .enq()?;
                     }
 
                     // (5) Read results from the device into a vector (`::block` not shown):
@@ -175,8 +172,7 @@ impl Host {
                         .queue(&self.queue)
                         .offset(0)
                         .read(&mut data)
-                        .enq()
-                        .unwrap();
+                        .enq()?;
                     self.output_sender
                         .send(Message::ResultMessage(ResultMessage::new(
                             data,
@@ -184,8 +180,7 @@ impl Host {
                             res_size,
                             self.wg_size,
                             id,
-                        )))
-                        .unwrap();
+                        )))?;
                 }
                 m => println!("Invalid MessageType {:?} recived by host", m),
             }