1 files changed, 21 insertions, 28 deletions

diff --git a/src/solvers/gpu/output.rs b/src/solvers/gpu/output.rs
index 9cbef1a..2ff1d01 100644
--- a/src/solvers/gpu/output.rs
+++ b/src/solvers/gpu/output.rs
@@ -19,31 +19,22 @@ impl InBuffer {
             banned_requests: HashSet::new(),
         }
     }
-    fn read(&mut self) -> Option<Vec<RowResult>> {
+    fn read(&mut self) -> Result<Option<Vec<RowResult>>, super::GpuError> {
         loop {
-            //println!("{:?}", self.receiver.recv().unwrap());
-            //continue;
-
-            match self
-                .receiver
-                .recv()
-                .expect("Channel to Output Daemon broke")
-            {
+            match self.receiver.recv()? {
                 Message::ResultMessage(results) => {
                     if results.data.iter().any(|x| *x != 0) {
                         println!("Horay results!");
                         if let Some(result_walls) = self.row_requests.get(&results.id) {
-                            return Some(Self::calc_results(
+                            return Ok(Some(Self::calc_results(
                                 results.valid_walls().as_ref(),
                                 result_walls,
-                            ));
+                            )));
                         } else {
                             self.results_requests.insert(results.id, results);
                         }
-                    } else {
-                        if self.row_requests.remove(&results.id).is_none() {
-                            self.banned_requests.insert(results.id);
-                        }
+                    } else if self.row_requests.remove(&results.id).is_none() {
+                        self.banned_requests.insert(results.id);
                     }
                 }
                 Message::OutputMessage((id, output)) => {
@@ -51,19 +42,19 @@ impl InBuffer {
                         continue;
                     }
                     if let Some(results) = self.results_requests.get(&id) {
-                        return Some(Self::calc_results(
+                        return Ok(Some(Self::calc_results(
                             results.valid_walls().as_ref(),
                             output.as_ref(),
-                        ));
+                        )));
                     } else {
                         self.row_requests.insert(id, output);
                     }
                 }
                 Message::CpuDone => {
-                    return None;
+                    return Ok(None);
                 }
                 Message::Terminate => {
-                    return None;
+                    return Ok(None);
                 }
                 _ => {
                     println!("Invalid MessageType");
@@ -86,7 +77,9 @@ impl InBuffer {
 
 pub struct Output {
     input: InBuffer,
+    #[allow(unused)]
     permutations: Vec<Vec<u32>>,
+    #[allow(unused)]
     permutations_mask: Vec<u64>,
     results: HashSet<RowResult>,
     result_sender: Sender<Message>,
@@ -113,21 +106,21 @@ impl Output {
             std::thread::Builder::new()
                 .name("GPU Output Deamon".into())
                 .spawn(move || {
-                    output.run();
+                    if let Err(err) = output.run() {
+                        println!("{}", err);
+                    }
                 })
                 .unwrap(),
         )
     }
 
-    fn run(mut self) {
+    fn run(mut self) -> Result<(), super::GpuError> {
         loop {
-            if let Some(walls) = self.input.read() {
+            if let Some(walls) = self.input.read()? {
                 for wall in walls {
                     if !self.results.contains(&wall) {
                         wall.output();
-                        self.result_sender
-                            .send(Message::RowResult(wall.clone()))
-                            .or_else(|_| Err(println!("Failed to transmit result back")));
+                        self.result_sender.send(Message::RowResult(wall.clone()))?;
                     }
                     self.results.insert(wall);
                 }
@@ -135,10 +128,10 @@ impl Output {
                 for wall in self.results {
                     wall.output()
                 }
-                self.result_sender.send(Message::GpuDone).unwrap();
+                self.result_sender.send(Message::GpuDone)?;
                 // wait for second exit signal
-                self.input.read();
-                return;
+                self.input.read()?;
+                return Ok(());
             }
         }
     }