Thread safety for error handler function pointer

Author: 9prady9

Cargo.toml

@@ -15,6 +15,7 @@ build         = "build.rs"
 libc = "0.1.10"
 num  = "0.1.27"
 time = "0.1.32"
+lazy_static = "0.2.1"
 
 [build-dependencies]
 rustc-serialize = "0.3.16"

src/error.rs

@@ -1,15 +1,44 @@
+use std::ops::{Deref, DerefMut};
 use defines::AfError;
 use std::error::Error;
+use std::marker::{Send, Sync};
+use std::sync::RwLock;
+
 
 pub type ErrorCallback = Fn(AfError);
 
-pub static mut HANDLE_ERROR: &'static ErrorCallback = &handle_error_general; 
+
+/// Wrap ErrorCallback function pointer inside a structure
+/// to enable implementing Send, Sync traits on it.
+pub struct Callback<'cblifetime> {
+    pub cb: &'cblifetime ErrorCallback,
+}
+
+
+// Implement Send, Sync traits for Callback structure to
+// enable the user of Callback function pointer in conjunction
+// with threads using a mutex.
+unsafe impl<'cblifetime> Send for Callback<'cblifetime> {}
+unsafe impl<'cblifetime> Sync for Callback<'cblifetime> {}
+
+
+pub static DEFAULT_HANDLE_ERROR: &'static ErrorCallback = &handle_error_general;
+
+
+lazy_static! {
+    static ref ERROR_HANDLER_LOCK: RwLock< Callback<'static> > =
+        RwLock::new(Callback{cb: DEFAULT_HANDLE_ERROR});
+}
+
 
 #[allow(unused_must_use)]
-pub fn register_error_handler(callback: &'static ErrorCallback) {
-    unsafe {
-        HANDLE_ERROR = callback;
-    }
+pub fn register_error_handler(cb_value: &'static ErrorCallback) {
+    let mut gaurd = match ERROR_HANDLER_LOCK.write() {
+        Ok(g) => g,
+        Err(_)=> panic!("Failed to acquire lock to register error handler"),
+    };
+
+    *gaurd.deref_mut() = Callback{cb:cb_value};
 }
 
 pub fn handle_error_general(error_code: AfError) {
@@ -18,3 +47,15 @@ pub fn handle_error_general(error_code: AfError) {
         _ => panic!("Error message: {}", error_code.description()),
     }
 }
+
+#[allow(non_snake_case)]
+pub fn HANDLE_ERROR(error_code: AfError) {
+    let gaurd = match ERROR_HANDLER_LOCK.read() {
+        Ok(g) => g,
+        Err(_)=> panic!("Failed to acquire lock while handling FFI return value"),
+    };
+
+    let func = gaurd.deref().cb;
+
+    func(error_code);
+}

src/lib.rs

@@ -2,6 +2,9 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://arrayfire.com/docs/rust")]
 
+#[macro_use]
+extern crate lazy_static;
+
 pub use array::Array;
 pub use array::{print};
 mod array;
@@ -50,7 +53,7 @@ mod defines;
 pub use dim4::Dim4;
 mod dim4;
 
-pub use error::{ErrorCallback, register_error_handler,handle_error_general};
+pub use error::{ErrorCallback, register_error_handler, handle_error_general};
 mod error;
 
 pub use index::{Indexer, index, row, rows, col, cols, slice, slices,

tests/lib.rs

@@ -1,42 +1,58 @@
+#[macro_use]
 extern crate arrayfire as af;
 
 use std::error::Error;
 use std::thread;
 use std::time::Duration;
 use af::*;
 
-pub fn handler_sample1(error_code: AfError) {
-    println!("Error handler sample1");
-    match error_code {
-        AfError::SUCCESS => {}, /* No-op */
-        _ => panic!("Error message: {}", error_code.description()),
-    }
-}
+macro_rules! implement_handler {
+    ($fn_name:ident, $msg: expr) => (
 
-pub fn handler_sample2(error_code: AfError) {
-    println!("Error handler sample2");
-    match error_code {
-        AfError::SUCCESS => {}, /* No-op */
-        _ => panic!("Error message: {}", error_code.description()),
-    }
+        pub fn $fn_name(error_code: AfError) {
+            println!("{:?}", $msg);
+            match error_code {
+                AfError::SUCCESS => {}, /* No-op */
+                _ => panic!("Error message: {}", error_code.description()),
+            }
+        }
+
+    )
 }
 
+implement_handler!(handler_sample1, "Error Handler Sample1");
+implement_handler!(handler_sample2, "Error Handler Sample2");
+implement_handler!(handler_sample3, "Error Handler Sample3");
+implement_handler!(handler_sample4, "Error Handler Sample4");
+
 pub static HANDLE1: &'static ErrorCallback = &handler_sample1;
 pub static HANDLE2: &'static ErrorCallback = &handler_sample2;
+pub static HANDLE3: &'static ErrorCallback = &handler_sample3;
+pub static HANDLE4: &'static ErrorCallback = &handler_sample4;
 
+#[allow(unused_must_use)]
 #[test]
 fn check_error_handler_mutation() {
 
     for i in 0..4 {
-        thread::spawn(move || {
-            if i%2==0 {
-                register_error_handler(HANDLE2);
-            } else {
-                register_error_handler(HANDLE1);
+        thread::Builder::new().name(format!("child {}",i+1).to_string()).spawn(move || {
+            println!("{:?}", thread::current());
+            match i {
+                0 => register_error_handler(HANDLE1.clone()),
+                1 => register_error_handler(HANDLE2.clone()),
+                2 => register_error_handler(HANDLE3.clone()),
+                3 => register_error_handler(HANDLE4.clone()),
+                _ => panic!("Impossible scenario"),
             }
+            //match i {
+            //    1 => thread::sleep(Duration::from_millis(20)),
+            //    2 => thread::sleep(Duration::from_millis(10)),
+            //    _ => (),
+            //}
         });
     }
 
+    af::info();
     thread::sleep(Duration::from_millis(50));
 
 }