Adding error checking to all clib function calls

Author: pavanky

arrayfire/algorithm.py

@@ -4,13 +4,13 @@
 
 def parallel_dim(a, dim, c_func):
     out = array()
-    c_func(pointer(out.arr), a.arr, c_int(dim))
+    safe_call(c_func(pointer(out.arr), a.arr, c_int(dim)))
     return out
 
 def reduce_all(a, c_func):
     real = c_double(0)
     imag = c_double(0)
-    c_func(pointer(real), pointer(imag), a.arr)
+    safe_call(c_func(pointer(real), pointer(imag), a.arr))
     real = real.value
     imag = imag.value
     return real if imag == 0 else real + imag * 1j
@@ -61,13 +61,13 @@ def imin(a, dim=None):
     if dim is not None:
         out = array()
         idx = array()
-        clib.af_imin(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim))
+        safe_call(clib.af_imin(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
         return out,idx
     else:
         real = c_double(0)
         imag = c_double(0)
         idx  = c_uint(0)
-        clib.af_imin_all(pointer(real), pointer(imag), pointer(idx), a.arr)
+        safe_call(clib.af_imin_all(pointer(real), pointer(imag), pointer(idx), a.arr))
         real = real.value
         imag = imag.value
         val = real if imag == 0 else real + imag * 1j
@@ -77,13 +77,13 @@ def imax(a, dim=None):
     if dim is not None:
         out = array()
         idx = array()
-        clib.af_imax(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim))
+        safe_call(clib.af_imax(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
         return out,idx
     else:
         real = c_double(0)
         imag = c_double(0)
         idx  = c_uint(0)
-        clib.af_imax_all(pointer(real), pointer(imag), pointer(idx), a.arr)
+        safe_call(clib.af_imax_all(pointer(real), pointer(imag), pointer(idx), a.arr))
         real = real.value
         imag = imag.value
         val = real if imag == 0 else real + imag * 1j
@@ -95,7 +95,7 @@ def accum(a, dim=0):
 
 def where(a):
     out = array()
-    clib.af_where(pointer(out.arr), a.arr)
+    safe_call(clib.af_where(pointer(out.arr), a.arr))
     return out
 
 def diff1(a, dim=0):
@@ -106,33 +106,34 @@ def diff2(a, dim=0):
 
 def sort(a, dim=0, is_ascending=True):
     out = array()
-    clib.af_sort(pointer(out.arr), a.arr, c_uint(dim), c_bool(is_ascending))
+    safe_call(clib.af_sort(pointer(out.arr), a.arr, c_uint(dim), c_bool(is_ascending)))
     return out
 
 def sort_index(a, dim=0, is_ascending=True):
     out = array()
     idx = array()
-    clib.af_sort_index(pointer(out.arr), pointer(idx.arr), a.arr, c_uint(dim), c_bool(is_ascending))
+    safe_call(clib.af_sort_index(pointer(out.arr), pointer(idx.arr), a.arr, \
+                                 c_uint(dim), c_bool(is_ascending)))
     return out,idx
 
 def sort_by_key(iv, ik, dim=0, is_ascending=True):
     ov = array()
     ok = array()
-    clib.af_sort_by_key(pointer(ov.arr), pointer(ok.arr), \
-                        iv.arr, ik.arr, c_uint(dim), c_bool(is_ascending))
+    safe_call(clib.af_sort_by_key(pointer(ov.arr), pointer(ok.arr), \
+                                  iv.arr, ik.arr, c_uint(dim), c_bool(is_ascending)))
     return ov,ok
 
 def set_unique(a, is_sorted=False):
     out = array()
-    clib.af_set_unique(pointer(out.arr), a.arr, c_bool(is_sorted))
+    safe_call(clib.af_set_unique(pointer(out.arr), a.arr, c_bool(is_sorted)))
     return out
 
 def set_union(a, b, is_unique=False):
     out = array()
-    clib.af_set_union(pointer(out.arr), a.arr, b.arr, c_bool(is_unique))
+    safe_call(clib.af_set_union(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
     return out
 
 def set_intersect(a, b, is_unique=False):
     out = array()
-    clib.af_set_intersect(pointer(out.arr), a.arr, b.arr, c_bool(is_unique))
+    safe_call(clib.af_set_intersect(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
     return out

arrayfire/array.py

@@ -6,7 +6,7 @@
 def create_array(buf, numdims, idims, dtype):
     out_arr = c_longlong(0)
     c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
-    clib.af_create_array(pointer(out_arr), c_longlong(buf), numdims, pointer(c_dims), dtype)
+    safe_call(clib.af_create_array(pointer(out_arr), c_longlong(buf), numdims, pointer(c_dims), dtype))
     return out_arr
 
 def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
@@ -23,16 +23,16 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
         if (dtype != c32 and dtype != c64):
             dtype = c32
 
-        clib.af_constant_complex(pointer(out), c_real, c_imag, 4, pointer(dims), dtype)
+        safe_call(clib.af_constant_complex(pointer(out), c_real, c_imag, 4, pointer(dims), dtype))
     elif dtype == s64:
         c_val = c_longlong(val.real)
-        clib.af_constant_long(pointer(out), c_val, 4, pointer(dims))
+        safe_call(clib.af_constant_long(pointer(out), c_val, 4, pointer(dims)))
     elif dtype == u64:
         c_val = c_ulonglong(val.real)
-        clib.af_constant_ulong(pointer(out), c_val, 4, pointer(dims))
+        safe_call(clib.af_constant_ulong(pointer(out), c_val, 4, pointer(dims)))
     else:
         c_val = c_double(val)
-        clib.af_constant(pointer(out), c_val, 4, pointer(dims), dtype)
+        safe_call(clib.af_constant(pointer(out), c_val, 4, pointer(dims), dtype))
 
     return out
 
@@ -49,7 +49,7 @@ def binary_func(lhs, rhs, c_func):
     elif not isinstance(rhs, array):
         TypeError("Invalid parameter to binary function")
 
-    c_func(pointer(out.arr), lhs.arr, other.arr, False)
+    safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
 
     return out
 
@@ -129,21 +129,21 @@ def __del__(self):
 
     def numdims(self):
         nd = c_uint(0)
-        clib.af_get_numdims(pointer(nd), self.arr)
+        safe_call(clib.af_get_numdims(pointer(nd), self.arr))
         return nd.value
 
     def dims(self):
         d0 = c_longlong(0)
         d1 = c_longlong(0)
         d2 = c_longlong(0)
         d3 = c_longlong(0)
-        clib.af_get_dims(pointer(d0), pointer(d1), pointer(d2), pointer(d3), self.arr)
+        safe_call(clib.af_get_dims(pointer(d0), pointer(d1), pointer(d2), pointer(d3), self.arr))
         dims = (d0.value,d1.value,d2.value,d3.value)
         return dims[:self.numdims()]
 
     def type(self):
         dty = f32
-        clib.af_get_type(pointer(dty), self.arr)
+        safe_call(clib.af_get_type(pointer(dty), self.arr))
         return dty
 
     def __add__(self, other):
@@ -286,3 +286,6 @@ def __nonzero__(self):
     # TODO:
     # def __abs__(self):
     #     return self
+
+def print_array(a):
+    safe_call(clib.af_print_array(a.arr))

arrayfire/data.py

@@ -18,7 +18,7 @@ def range(d0, d1=None, d2=None, d3=None, dim=-1, dtype=f32):
     out = array()
     dims = dim4(d0, d1, d2, d3)
 
-    clib.af_range(pointer(out.arr), 4, pointer(dims), dim, dtype)
+    safe_call(clib.af_range(pointer(out.arr), 4, pointer(dims), dim, dtype))
     return out
 
 
@@ -36,7 +36,7 @@ def iota(d0, d1=None, d2=None, d3=None, dim=-1, tile_dims=None, dtype=f32):
 
     tdims = dim4(td[0], td[1], td[2], td[3])
 
-    clib.af_iota(pointer(out.arr), 4, pointer(dims), 4, pointer(tdims), dtype)
+    safe_call(clib.af_iota(pointer(out.arr), 4, pointer(dims), 4, pointer(tdims), dtype))
     return out
 
 def randu(d0, d1=None, d2=None, d3=None, dtype=f32):
@@ -47,7 +47,7 @@ def randu(d0, d1=None, d2=None, d3=None, dtype=f32):
     out = array()
     dims = dim4(d0, d1, d2, d3)
 
-    clib.af_randu(pointer(out.arr), 4, pointer(dims), dtype)
+    safe_call(clib.af_randu(pointer(out.arr), 4, pointer(dims), dtype))
     return out
 
 def randn(d0, d1=None, d2=None, d3=None, dtype=f32):
@@ -58,15 +58,15 @@ def randn(d0, d1=None, d2=None, d3=None, dtype=f32):
     out = array()
     dims = dim4(d0, d1, d2, d3)
 
-    clib.af_randn(pointer(out.arr), 4, pointer(dims), dtype)
+    safe_call(clib.af_randn(pointer(out.arr), 4, pointer(dims), dtype))
     return out
 
 def set_seed(seed=0):
-    clib.af_set_seed(c_ulonglong(seed))
+    safe_call(clib.af_set_seed(c_ulonglong(seed)))
 
 def get_seed():
     seed = c_ulonglong(0)
-    clib.af_get_seed(pointer(seed))
+    safe_call(clib.af_get_seed(pointer(seed)))
     return seed.value
 
 def identity(d0, d1=None, d2=None, d3=None, dtype=f32):
@@ -77,21 +77,21 @@ def identity(d0, d1=None, d2=None, d3=None, dtype=f32):
     out = array()
     dims = dim4(d0, d1, d2, d3)
 
-    clib.af_identity(pointer(out.arr), 4, pointer(dims), dtype)
+    safe_call(clib.af_identity(pointer(out.arr), 4, pointer(dims), dtype))
     return out
 
 def diag(a, num=0, extract=True):
     out = array()
     if extract:
-        clib.af_diag_extract(pointer(out.arr), a.arr, c_int(num))
+        safe_call(clib.af_diag_extract(pointer(out.arr), a.arr, c_int(num)))
     else:
-        clib.af_diag_create(pointer(out.arr), a.arr, c_int(num))
+        safe_call(clib.af_diag_create(pointer(out.arr), a.arr, c_int(num)))
     return out
 
 def join(dim, first, second, third=None, fourth=None):
     out = array()
     if (third is None and fourth is None):
-        clib.af_join(pointer(out.arr), dim, first.arr, second.arr)
+        safe_call(clib.af_join(pointer(out.arr), dim, first.arr, second.arr))
     else:
         c_array_vec = dim4(first, second, 0, 0)
         num = 2
@@ -102,47 +102,47 @@ def join(dim, first, second, third=None, fourth=None):
             c_array_vec[num] = fourth.arr
             num+=1
 
-        clib.af_join_many(pointer(out.arr), dim, num, pointer(c_array_vec))
+        safe_call(clib.af_join_many(pointer(out.arr), dim, num, pointer(c_array_vec)))
 
 
 def tile(a, d0, d1=1, d2=1, d3=1):
     out = array()
-    clib.af_tile(pointer(out.arr), a.arr, d0, d1, d2, d3)
+    safe_call(clib.af_tile(pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 
 def reorder(a, d0=1, d1=0, d2=2, d3=3):
     out = array()
-    clib.af_reorder(pointer(out.arr), a.arr, d0, d1, d2, d3)
+    safe_call(clib.af_reorder(pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 def shift(a, d0, d1=0, d2=0, d3=0):
     out = array()
-    clib.af_shift(pointer(out.arr), a.arr, d0, d1, d2, d3)
+    safe_call(clib.af_shift(pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 def moddims(a, d0, d1=1, d2=1, d3=1):
     out = array()
     dims = dim4(d0, d1, d2, d3)
-    clib.af_moddims(pointer(out.arr), a.arr, 4, pointer(dims))
+    safe_call(clib.af_moddims(pointer(out.arr), a.arr, 4, pointer(dims)))
     return out
 
 def flat(a):
     out = array()
-    clib.af_flat(pointer(out.arr), a.arr)
+    safe_call(clib.af_flat(pointer(out.arr), a.arr))
     return out
 
 def flip(a, dim=0):
     out = array()
-    clib.af_flip(pointer(out.arr), a.arr, c_int(dim))
+    safe_call(clib.af_flip(pointer(out.arr), a.arr, c_int(dim)))
     return out
 
 def lower(a, is_unit_diag=False):
     out = array()
-    clib.af_lower(pointer(out.arr), a.arr, is_unit_diag)
+    safe_call(clib.af_lower(pointer(out.arr), a.arr, is_unit_diag))
     return out
 
 def upper(a, is_unit_diag=False):
     out = array()
-    clib.af_upper(pointer(out.arr), a.arr, is_unit_diag)
+    safe_call(clib.af_upper(pointer(out.arr), a.arr, is_unit_diag))
     return out

arrayfire/util.py

@@ -1,5 +1,5 @@
+import inspect
 from .library import *
-from .array import *
 
 def dim4(d0=1, d1=1, d2=1, d3=1):
     c_dim4 = c_longlong * 4
@@ -19,8 +19,12 @@ def dim4_tuple(dims):
 
     return tuple(out)
 
-def print_array(a):
-    clib.af_print_array(a.arr)
-
 def is_valid_scalar(a):
     return isinstance(a, float) or isinstance(a, int) or isinstance(a, complex)
+
+def safe_call(af_error):
+    if (af_error != AF_SUCCESS.value):
+        c_err_str = c_char_p(0)
+        c_err_len = c_longlong(0)
+        clib.af_get_last_error(pointer(c_err_str), pointer(c_err_len))
+        raise RuntimeError(c_err_str.value, af_error)