Merge pull request #291 from abergeron/for_release

Small changes for the release

Author: nouiz

pygpu/gpuarray.pxd

@@ -49,8 +49,6 @@ cdef extern from "gpuarray/types.h":
         GA_NBASE
 
 cdef extern from "gpuarray/util.h":
-    const int gpuarray_api_major
-    const int gpuarray_api_minor
     int gpuarray_register_type(gpuarray_type *t, int *ret)
     size_t gpuarray_get_elsize(int typecode)
     gpuarray_type *gpuarray_get_type(int typecode)
@@ -75,6 +73,7 @@ cdef extern from "gpuarray/buffer.h":
     gpucontext *gpucontext_init(const char *name, int devno, int flags, int *ret)
     void gpucontext_deref(gpucontext *ctx)
     char *gpucontext_error(gpucontext *ctx, int err)
+    int gpudata_property(gpudata *ctx, int prop_id, void *res)
     int gpucontext_property(gpucontext *ctx, int prop_id, void *res)
     int gpukernel_property(gpukernel *k, int prop_id, void *res)
     gpucontext *gpudata_context(gpudata *)
@@ -101,6 +100,9 @@ cdef extern from "gpuarray/buffer.h":
     int GA_CTX_PROP_MAXGSIZE0
     int GA_CTX_PROP_MAXGSIZE1
     int GA_CTX_PROP_MAXGSIZE2
+
+    int GA_BUFFER_PROP_SIZE
+
     int GA_KERNEL_PROP_MAXLSIZE
     int GA_KERNEL_PROP_PREFLSIZE
     int GA_KERNEL_PROP_NUMARGS
@@ -151,6 +153,7 @@ cdef extern from "gpuarray/array.h":
     ctypedef enum ga_order:
         GA_ANY_ORDER, GA_C_ORDER, GA_F_ORDER
 
+    void GpuArray_fix_flags(_GpuArray *a)
     int GpuArray_empty(_GpuArray *a, gpucontext *ctx,
                        int typecode, int nd, const size_t *dims, ga_order ord)
     int GpuArray_fromdata(_GpuArray *a,

pygpu/gpuarray.pyx

@@ -10,8 +10,8 @@ from cpython cimport Py_INCREF, PyNumber_Index
 from cpython.object cimport Py_EQ, Py_NE
 
 def api_version():
-    # major, minor, py
-    return (gpuarray_api_major, gpuarray_api_minor, 0)
+    # Those where the last defined numbers.
+    return (-9997, 1, 0)
 
 np.import_array()
 
@@ -212,6 +212,35 @@ cdef ga_order to_ga_order(ord) except <ga_order>-2:
     else:
         raise ValueError, "Valid orders are: 'A' (any), 'C' (C), 'F' (Fortran)"
 
+cdef int strides_ok(GpuArray a, strides):
+    # Check that the passed in strides will not go outside of the
+    # memory of the array.  It is assumed that the strides are of the
+    # proper length.
+    cdef ssize_t max_axis_offset
+    cdef size_t lower = a.ga.offset
+    cdef size_t upper = a.ga.offset
+    cdef size_t itemsize = gpuarray_get_elsize(a.ga.typecode)
+    cdef size_t size
+    cdef unsigned int i
+
+    gpudata_property(a.ga.data, GA_BUFFER_PROP_SIZE, &size)
+
+    for i in range(a.ga.nd):
+        if a.ga.dimensions[i] == 0:
+            return 1
+
+        max_axis_offset = strides[i] * (a.ga.dimensions[i] - 1)
+        if max_axis_offset > 0:
+            if upper + max_axis_offset > size:
+                return 0
+            upper += max_axis_offset
+        else:
+            if lower < -max_axis_offset:
+                return 0
+            lower += max_axis_offset
+    return (upper + itemsize) <= size
+
+
 class GpuArrayException(Exception):
     """
     Exception used for most errors related to libgpuarray.
@@ -234,6 +263,9 @@ cdef bint py_CHKFLAGS(GpuArray a, int flags):
 cdef bint py_ISONESEGMENT(GpuArray a):
     return GpuArray_ISONESEGMENT(&a.ga)
 
+cdef void array_fix_flags(GpuArray a):
+    GpuArray_fix_flags(&a.ga)
+
 cdef int array_empty(GpuArray a, gpucontext *ctx,
                      int typecode, unsigned int nd, const size_t *dims,
                      ga_order ord) except -1:
@@ -564,12 +596,6 @@ def init(dev, sched='default', disable_alloc_cache=False, single_stream=False):
     are no gaps in the valid numbers.
     """
     cdef int flags = 0
-    expected_version = -9997
-    if gpuarray_api_major != expected_version or gpuarray_api_minor < 0:
-        raise RuntimeError(
-            "Pygpu was expecting libgpuarray version %d, but %d is available. "
-            "Recompile it to avoid problems.",
-            expected_version, gpuarray_api_major)
     if sched == 'single':
         flags |= GA_CTX_SINGLE_THREAD
     elif sched == 'multi':
@@ -1943,6 +1969,16 @@ cdef class GpuArray:
                 res[i] = self.ga.strides[i]
             return tuple(res)
 
+        def __set__(self, newstrides):
+            cdef unsigned int i
+            if len(newstrides) != self.ga.nd:
+                raise ValueError("new strides are the wrong length")
+            if not strides_ok(self,  newstrides):
+                raise ValueError("new strides go outside of allocated memory")
+            for i in range(self.ga.nd):
+                self.ga.strides[i] = newstrides[i]
+            array_fix_flags(self)
+
     property ndim:
         "The number of dimensions in this object"
         def __get__(self):

pygpu/tests/test_gpu_ndarray.py

@@ -8,6 +8,7 @@
 
 import numpy
 
+from nose.tools import assert_raises
 import pygpu
 from pygpu.gpuarray import GpuArray, GpuContext, GpuKernel
 
@@ -448,6 +449,32 @@ def reshape(shps, offseted, order1, order2):
     assert numpy.allclose(outc, numpy.asarray(outg))
 
 
+def test_strides():
+    yield strides_, (4, 4), 'c', 1, (4, 4)
+    yield strides_, (4, 4), 'c', 1, (4, 16)
+    yield strides_, (4, 4), 'c', 1, (16, 4)
+    yield strides_, (4, 4), 'c', 1, (16, 8)
+    yield strides_, (4, 4), 'c', 1, (16, 0)
+    yield strides_, (4, 4), 'c', -1, (-20, 4)
+    yield strides_, (4, 4), 'c', -1, (-12, 4)
+
+
+def set_strides(a, newstr):
+    a.strides = newstr
+
+
+def strides_(shp, order, sliced, newstr):
+    ac, ag = gen_gpuarray(shp, 'float32', sliced=sliced, order=order, ctx=ctx)
+    try:
+        ac.strides = newstr
+    except ValueError:
+        assert_raises(ValueError, set_strides, ag, newstr)
+        return
+    ag.strides = newstr
+    check_flags(ag, ac)
+    assert numpy.allclose(ac, numpy.asarray(ag))
+
+
 def test_transpose():
     for shp in [(2, 3), (4, 8, 9), (1, 2, 3, 4)]:
         for offseted in [True, False]:

src/CMakeLists.txt

@@ -87,6 +87,8 @@ set_target_properties(gpuarray PROPERTIES
   COMPILE_FLAGS "-DGPUARRAY_BUILDING_DLL -DGPUARRAY_SHARED"
   INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib
   MACOSX_RPATH OFF
+  # This is the shared library version
+  VERSION 0.0
   )
 
 add_library(gpuarray-static STATIC ${GPUARRAY_SRC})

src/gpuarray/array.h

@@ -196,6 +196,13 @@ static inline int GpuArray_CHKFLAGS(const GpuArray *a, int flags) {
  */
 #define GpuArray_ITEMSIZE(a) gpuarray_get_elsize((a)->typecode)
 
+/**
+ * Fix the flags of an array using the current strides and shape.
+ *
+ * \param a GpuArray to fix flags for
+ */
+GPUARRAY_PUBLIC void GpuArray_fix_flags(GpuArray *a);
+
 /**
  * Initialize and allocate a new empty (uninitialized data) array.
  *

src/gpuarray/util.h

@@ -15,9 +15,6 @@ extern "C" {
 #include <gpuarray/elemwise.h>
 #include <gpuarray/types.h>
 
-extern GPUARRAY_PUBLIC const int gpuarray_api_major;
-extern GPUARRAY_PUBLIC const int gpuarray_api_minor;
-
 /**
  * Registers a type with the kernel machinery.
  *

src/gpuarray_array.c

@@ -85,9 +85,17 @@ static int ga_extcopy(GpuArray *dst, const GpuArray *src) {
 /* Value below which a size_t multiplication will never overflow. */
 #define MUL_NO_OVERFLOW (1UL << (sizeof(size_t) * 4))
 
-int GpuArray_empty(GpuArray *a, gpucontext *ctx,
-		   int typecode, unsigned int nd, const size_t *dims,
-                   ga_order ord) {
+void GpuArray_fix_flags(GpuArray *a) {
+  /* Only keep the writable flag */
+  a->flags &= GA_WRITEABLE;
+  /* Set the other flags if applicable */
+  if (GpuArray_is_c_contiguous(a)) a->flags |= GA_C_CONTIGUOUS;
+  if (GpuArray_is_f_contiguous(a)) a->flags |= GA_F_CONTIGUOUS;
+  if (GpuArray_is_aligned(a)) a->flags |= GA_ALIGNED;
+}
+
+int GpuArray_empty(GpuArray *a, gpucontext *ctx, int typecode,
+                   unsigned int nd, const size_t *dims, ga_order ord) {
   size_t size = gpuarray_get_elsize(typecode);
   unsigned int i;
   int res = GA_NO_ERROR;
@@ -185,9 +193,7 @@ int GpuArray_fromdata(GpuArray *a, gpudata *data, size_t offset, int typecode,
   memcpy(a->dimensions, dims, nd*sizeof(size_t));
   memcpy(a->strides, strides, nd*sizeof(ssize_t));
 
-  if (GpuArray_is_c_contiguous(a)) a->flags |= GA_C_CONTIGUOUS;
-  if (GpuArray_is_f_contiguous(a)) a->flags |= GA_F_CONTIGUOUS;
-  if (GpuArray_is_aligned(a)) a->flags |= GA_ALIGNED;
+  GpuArray_fix_flags(a);
 
   return GA_NO_ERROR;
 }
@@ -304,18 +310,7 @@ int GpuArray_index_inplace(GpuArray *a, const ssize_t *starts,
   a->dimensions = newdims;
   free(a->strides);
   a->strides = newstrs;
-  if (GpuArray_is_c_contiguous(a))
-    a->flags |= GA_C_CONTIGUOUS;
-  else
-    a->flags &= ~GA_C_CONTIGUOUS;
-  if (GpuArray_is_f_contiguous(a))
-    a->flags |= GA_F_CONTIGUOUS;
-  else
-    a->flags &= ~GA_F_CONTIGUOUS;
-  if (GpuArray_is_aligned(a))
-    a->flags |= GA_ALIGNED;
-  else
-    a->flags &= ~GA_ALIGNED;
+  GpuArray_fix_flags(a);
 
   return GA_NO_ERROR;
 }
@@ -582,9 +577,8 @@ int GpuArray_setarray(GpuArray *a, const GpuArray *v) {
   tv.nd = a->nd;
   tv.dimensions = a->dimensions;
   tv.strides = strs;
-  /* This could be optiomized by setting the right flags */
   if (tv.nd != 0)
-    tv.flags &= ~(GA_C_CONTIGUOUS|GA_F_CONTIGUOUS);
+    GpuArray_fix_flags(&tv);
   err = ga_extcopy(a, &tv);
   free(strs);
   return err;
@@ -745,18 +739,7 @@ int GpuArray_reshape_inplace(GpuArray *a, unsigned int nd,
   a->strides = newstrides;
 
  fix_flags:
-  if (GpuArray_is_c_contiguous(a))
-    a->flags |= GA_C_CONTIGUOUS;
-  else
-    a->flags &= ~GA_C_CONTIGUOUS;
-  if (GpuArray_is_f_contiguous(a))
-    a->flags |= GA_F_CONTIGUOUS;
-  else
-    a->flags &= ~GA_F_CONTIGUOUS;
-  if (GpuArray_is_aligned(a))
-    a->flags |= GA_ALIGNED;
-  else
-    a->flags &= ~GA_ALIGNED;
+  GpuArray_fix_flags(a);
   return GA_NO_ERROR;
 }
 
@@ -808,11 +791,7 @@ int GpuArray_transpose_inplace(GpuArray *a, const unsigned int *new_axes) {
   a->dimensions = newdims;
   a->strides = newstrs;
 
-  a->flags &= ~(GA_C_CONTIGUOUS|GA_F_CONTIGUOUS);
-  if (GpuArray_is_c_contiguous(a))
-    a->flags |= GA_C_CONTIGUOUS;
-  if (GpuArray_is_f_contiguous(a))
-    a->flags |= GA_F_CONTIGUOUS;
+  GpuArray_fix_flags(a);
 
   return GA_NO_ERROR;
 }
@@ -1016,10 +995,9 @@ int GpuArray_concatenate(GpuArray *r, const GpuArray **as, size_t n,
   res_off = r->offset;
   res_dims = r->dimensions;
   res_flags = r->flags;
-  /* This could be optimized by setting the right flags */
-  r->flags &= ~(GA_C_CONTIGUOUS|GA_F_CONTIGUOUS);
   for (i = 0; i < n; i++) {
     r->dimensions = as[i]->dimensions;
+    GpuArray_fix_flags(r);
     err = ga_extcopy(r, as[i]);
     if (err != GA_NO_ERROR) {
       r->dimensions = res_dims;

src/gpuarray_buffer_cuda.c

@@ -399,8 +399,9 @@ static gpucontext *cuda_init(int ord, int flags, int *ret) {
     int r;
 
     r = setup_lib();
-    if (r != GA_NO_ERROR)
-      return NULL;
+    if (r != GA_NO_ERROR) {
+      FAIL(NULL, r);
+    }
 
     if (ord == -1) {
       int i, c;

src/gpuarray_util.c

@@ -13,9 +13,6 @@
  * phase. Once we go stable, this will move to 0 and go up from
  * there.
  */
-const int gpuarray_api_major = -9997;
-const int gpuarray_api_minor = 1;
-
 static gpuarray_type **custom_types = NULL;
 static int n_types = 0;
 static gpuarray_type no_type = {NULL, 0, 0, -1};