pyopencl 2024.2.2__cp39-cp39-macosx_10_14_x86_64.whl → 2024.2.5__cp39-cp39-macosx_10_14_x86_64.whl

pyopencl/__init__.py

@@ -30,6 +30,8 @@ import pyopencl.cltypes  # noqa: F401
 from pyopencl.version import VERSION, VERSION_STATUS, VERSION_TEXT  # noqa: F401
 
 
+__version__ = VERSION_TEXT
+
 logger = logging.getLogger(__name__)
 
 # This supports ocl-icd find shipped OpenCL ICDs, cf.
@@ -491,8 +493,16 @@ class Program:
             cache_dir = getattr(self._context, "cache_dir", None)
 
         build_descr = None
-        if _PYOPENCL_NO_CACHE and self._prg is None:
-            build_descr = "uncached source build (cache disabled by user)"
+        from pyopencl.characterize import has_src_build_cache
+
+        if (
+                (_PYOPENCL_NO_CACHE or has_src_build_cache(self._context.devices[0]))
+                and self._prg is None):
+            if _PYOPENCL_NO_CACHE:
+                build_descr = "uncached source build (cache disabled by user)"
+            else:
+                build_descr = "uncached source build (assuming cached by ICD)"
+
             self._prg = _cl._Program(self._context, self._source)
 
         from time import time
@@ -977,7 +987,8 @@ def _add_functionality():
             else:
                 raise ValueError("images cannot have more than three dimensions")
 
-            desc = ImageDescriptor()
+            desc = ImageDescriptor() \
+                # pylint: disable=possibly-used-before-assignment
 
             desc.image_type = image_type
             desc.shape = shape  # also sets desc.array_size
@@ -1352,7 +1363,8 @@ def _add_functionality():
         svm_old_init = SVM.__init__
 
     def svm_init(self, mem):
-        svm_old_init(self, mem)
+        if get_cl_header_version() >= (2, 0):
+            svm_old_init(self, mem)
 
         self.mem = mem
 

pyopencl/algorithm.py

@@ -1225,7 +1225,9 @@ class ListOfListsBuilder:
             info_record.compressed_indices = cl.array.empty(
                 queue, (n_objects + 1,), index_dtype, allocator=allocator)
             info_record.compressed_indices[0] = 0
-            compress_events[name] = compress_kernel(
+
+            compress_events[name] = compress_kernel( \
+                # pylint: disable=possibly-used-before-assignment
                 info_record.starts,
                 compressed_counts,
                 info_record.nonempty_indices,

pyopencl/bitonic_sort.py

@@ -225,6 +225,8 @@ class BitonicSort:
                 elif inc >= 0:
                     letter = "B2"
                     ninc = 1
+                else:
+                    raise AssertionError("Should not happen")
 
                 nthreads = size >> ninc
 

pyopencl/characterize/__init__.py

@@ -393,6 +393,8 @@ def has_struct_arg_count_bug(dev, ctx=None):
     return False
 
 
+# {{{ SVM capabilities
+
 def _may_have_svm(dev):
     has_svm = (dev.platform._get_cl_version() >= (2, 0)
             and cl.get_cl_header_version() >= (2, 0))
@@ -431,3 +433,24 @@ def has_fine_grain_buffer_svm_atomics(dev):
 def has_fine_grain_system_svm_atomics(dev):
     return has_fine_grain_system_svm(dev) and bool(dev.svm_capabilities
                 & cl.device_svm_capabilities.ATOMICS)
+
+# }}}
+
+
+def has_src_build_cache(dev: cl.Device) -> Optional[bool]:
+    """
+    Return *True* if *dev* has internal support for caching builds from source,
+    *False* if it doesn't, and *None* if unknown.
+    """
+    if dev.platform.name == "Portable Computing Language":
+        return True
+
+    if nv_compute_capability(dev) is not None:
+        return True
+
+    if dev.platform.name == "AMD Accelerated Parallel Processing":
+        return False
+
+    return None
+
+# vim: foldmethod=marker

pyopencl/compyte/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/pyopencl/compyte

pyopencl/compyte/.gitignore

@@ -0,0 +1,21 @@
+build
+.*.sw[po]
+.sw[po]
+*~
+*.pyc
+*.pyo
+*.egg-info
+MANIFEST
+dist
+setuptools*egg
+setuptools.pth
+distribute*egg
+distribute*tar.gz
+*.so
+*.o
+*.aux
+*.bbl
+*.blg
+*.log
+
+.cache

pyopencl/compyte/ndarray/Makefile

@@ -0,0 +1,31 @@
+all: pygpu_ndarray.so
+
+PYTHONVERSION ?= $(shell python -c "import sys; print '%d.%d'%(sys.version_info[0], sys.version_info[1]"))
+CUDA_ROOT ?= /opt/lisa/os/cuda
+THEANO_ROOT ?= /u/bastienf/repos/Theano
+
+
+CFLAGS=-g -DDEBUG -DOFFSET
+# By default enable the OFFSET usage. Otherwise some test fail.
+CFLAGS=-g -DOFFSET
+#BINDIR=--compiler-bindir ${HOME}/.theano.nvcc-bindir
+
+#NPY_PATH!=python -c "import numpy;print numpy.__path__"
+#NPY_INCLUDE=-I${NPY_PATH}/core/include
+CUDA_INCLUDE=-I${CUDA_ROOT}/include
+PYTHON_INCLUDE=-I$(shell python -c "import distutils.sysconfig;print distutils.sysconfig.get_python_inc()")
+INCLUDES=${CUDA_INCLUDE} ${PYTHON_INCLUDE}
+CUDA_FLAGS=-Xlinker -rpath,${CUDA_ROOT}/lib64 -Xlinker -rpath,${CUDA_ROOT}/lib
+
+pygpu_language_cuda.o: pygpu_language_cuda.cu pygpu_language.h
+	nvcc -c ${CFLAGS} -m64 -Xcompiler -fPIC,-m64 ${CUDA_FLAGS} ${INCLUDES} ${BINDIR} -o $@ $<
+
+pygpu_ndarray.so: pygpu_ndarray.cpp pygpu_ndarray.h pygpu_language_cuda.o pygpu_ndarray_object.h
+	nvcc -shared ${CFLAGS} -m64 -Xcompiler -fPIC,-m64 ${CUDA_FLAGS} ${INCLUDES} ${BINDIR} -o $@ pygpu_language_cuda.o $< -lpython${PYTHONVERSION} -lcublas -lcudart
+
+clean:
+	rm -f pygpu_ndarray.so core.* *.o *~
+	rm -rf build
+
+cleantmp:
+	rm -f core.* *.o *~

pyopencl/compyte/ndarray/gpu_ndarray.h

@@ -0,0 +1,35 @@
+#ifndef _GPU_NDARRAY_H
+#define _GPU_NDARRAY_H
+
+
+typedef struct GpuNdArray{
+  char* data; //pointer to data element [0,..,0].
+  int offset;
+  int nd; //the number of dimensions of the tensor
+
+  /**
+   * base:
+   *  either NULL or a pointer to a fellow CudaNdarray into which this one is viewing.
+   *  This pointer is never followed, except during Py_DECREF when we do not need it any longer.
+   */
+  void * base;
+  ssize_t  * dimensions; //dim0, dim1, ... dim nd
+  ssize_t * strides; //stride0, stride1, ... stride nd
+  int flags; // Flags, see numpy flags
+  //DTYPE dtype; // fine for numeric types
+  //DtypeMeta * dtype_meta; // reserved for future use.
+  //PyArray_Descr *descr;   /* Pointer to type structure */
+} GpuNdArray;
+
+#endif
+/*
+  Local Variables:
+  mode:c++
+  c-basic-offset:4
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0))
+  indent-tabs-mode:nil
+  fill-column:79
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=79 :

pyopencl/compyte/ndarray/pygpu_language.h

@@ -0,0 +1,207 @@
+/**
+ * This file contain the header for ALL code that depend on cuda or opencl.
+ */
+#ifndef _PYGPU_LANGUAGE_H
+#define _PYGPU_LANGUAGE_H
+#include <Python.h>
+//#include <iostream>
+
+#include "pygpu_ndarray_object.h"
+
+/////////////////////////
+// Alloc and Free
+/////////////////////////
+//If true, when there is a gpu malloc or free error, we print the size of allocated memory on the device.
+#define COMPUTE_GPU_MEM_USED 0
+#define VERBOSE_ALLOC_FREE 0
+//If true, we fill with NAN allocated device memory.
+#define ALLOC_MEMSET 0
+
+static int _outstanding_mallocs[] = {0,0};
+
+#ifdef DEBUG
+#define DPRINTF(args...) fprintf(stderr, args)
+#else
+#define DPRINTF(...)
+#endif
+
+#if COMPUTE_GPU_MEM_USED
+int _allocated_size = 0;
+const int TABLE_SIZE = 10000;
+struct table_struct{
+  void* ptr;
+  int size;
+};
+table_struct _alloc_size_table[TABLE_SIZE];
+#endif
+
+/**
+ * Allocation and freeing of device memory should go through these functions so that the lib can track memory usage.
+ *
+ * device_malloc will set the Python error message before returning None.
+ * device_free will return nonzero on failure (after setting the python error message)
+ */
+void * device_malloc(size_t size);
+int device_free(void * ptr);
+static PyObject *
+outstanding_mallocs(PyObject* self, PyObject * args)
+{
+    return PyInt_FromLong(_outstanding_mallocs[0]);
+}
+
+int PyGpuNdArray_CopyFromPyGpuNdArray(PyGpuNdArrayObject * self, PyGpuNdArrayObject * other, bool unbroadcast = false);
+
+/**
+ * PyGpuNdArray_alloc_contiguous
+ *
+ * Allocate storage space for a tensor of rank 'nd' and given dimensions.
+ *
+ * Note: PyGpuNdArray_alloc_contiguous is templated to work for both int dimensions and npy_intp dimensions
+ */
+template<typename inttype>
+int PyGpuNdArray_alloc_contiguous(PyGpuNdArrayObject *self, const int nd, const inttype * dim, NPY_ORDER order=NPY_CORDER)
+{
+    DPRINTF("PyGpuNdArray_alloc_contiguous: start nd=%i descr=%p\n", nd, self);
+
+    if (!PyGpuNdArray_DESCR(self)){
+        PyErr_SetString(PyExc_ValueError,
+                        "PyGpuNdArray_alloc_contiguous: The array don't have a type! We can't allocate it!\n");
+        return -1;
+    }
+    
+    // allocate an empty ndarray with c_contiguous access
+    // return 0 on success
+    int size = 1; //set up the strides for contiguous tensor
+    assert (nd >= 0);
+    if (PyGpuNdArray_set_nd(self, nd))
+    {
+        return -1;
+    }
+    //TODO: check if by any chance our current dims are correct,
+    //      and strides already contiguous
+    //      in that case we can return right here.
+    DPRINTF("PyGpuNdArray_alloc_contiguous: before itemsize descr=%p elsize=%i\n", self->descr, self->descr->elsize);
+    int elsize = PyGpuNdArray_ITEMSIZE((PyObject*)self);
+    DPRINTF("PyGpuNdArray_alloc_contiguous: set_nd %d! elsize=%i\n", nd, elsize);
+    if(order != NPY_FORTRANORDER){
+      DPRINTF("PyGpuNdArray_alloc_contiguous: NPY_CORDER\n");
+      for (int i = nd-1; i >= 0; --i){
+	if (size == 0)
+	  PyGpuNdArray_STRIDE(self, i) = elsize;
+	else
+	  PyGpuNdArray_STRIDE(self,i) = size * elsize;
+        PyGpuNdArray_DIM(self,i) = dim[i];
+        size = size * dim[i];
+      }
+    }else if (nd>0){
+      DPRINTF("PyGpuNdArray_alloc_contiguous: NPY_FORTRANORDER\n");
+      size = dim[0];
+      PyGpuNdArray_STRIDE(self, 0) = elsize;
+      PyGpuNdArray_DIM(self, nd-1) = dim[nd-1];
+      for (int i = 1; i < nd; ++i){
+	if (size == 0)
+	  PyGpuNdArray_STRIDE(self, i) = elsize;
+	else
+	  PyGpuNdArray_STRIDE(self, i) = PyGpuNdArray_STRIDE(self, i-1) * dim[i-1];
+        PyGpuNdArray_DIM(self, nd-i-1) = dim[nd-i-1];
+        size = size * dim[i];
+      }
+    }
+
+    if (self->data_allocated != size)
+    {
+        // If self is a view, do not try to free its memory
+        if (self->data_allocated && device_free(PyGpuNdArray_DATA(self))) {
+	  // Does this ever happen??  Do we need to set data_allocated or devdata to 0?
+	  PyGpuNdArray_DATA(self) = NULL;
+	  self->data_allocated = 0;
+	  return -1;
+	}
+
+        assert(size>0);
+	DPRINTF("PyGpuNdArray_alloc_contiguous: will allocate for size=%d elements\n", size);
+
+        PyGpuNdArray_DATA(self) = (char*)device_malloc(size * PyGpuNdArray_ITEMSIZE((PyObject *)self));
+        if (!PyGpuNdArray_DATA(self))
+        {
+            PyGpuNdArray_set_nd(self,-1);
+            self->data_allocated = 0;
+            PyGpuNdArray_DATA(self) = 0;
+            return -1;
+        }
+
+	// The structure of self will be reused with newly allocated memory.
+	// If self was a view, we should remove the reference to its base.
+	// (If base was already NULL, the following has no effect.)
+	Py_XDECREF(self->base);
+	self->base = NULL;
+
+        self->data_allocated = size;
+	self->gpu_ndarray.flags = NPY_DEFAULT;
+	PyGpuNdArray_FLAGS(self) |= NPY_WRITEABLE;
+	PyGpuNdArray_FLAGS(self) |= NPY_OWNDATA;
+	if (nd == 0) {
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	  if (order != NPY_FORTRANORDER) {
+	    PyGpuNdArray_FLAGS(self) &= ~NPY_F_CONTIGUOUS;
+	  } else {
+	    PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  }
+
+	}else if(nd == 1){//set c and f contiguous
+	  PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	}else if(order != NPY_FORTRANORDER){//set c contiguous
+	  PyGpuNdArray_FLAGS(self) &= ~NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	}else{//set f contiguous
+	  PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) &= ~NPY_C_CONTIGUOUS;
+	}
+	PyGpuNdArray_FLAGS(self) &= ~NPY_UPDATEIFCOPY;
+    }else if(size == 0){
+      PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+      PyGpuNdArray_FLAGS(self) |= NPY_OWNDATA;
+	if (nd == 0) {
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	  if (order != NPY_FORTRANORDER) {
+	    PyGpuNdArray_FLAGS(self) &= ~NPY_F_CONTIGUOUS;
+	  } else {
+	    PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  }
+
+	}else if(nd == 1){//set c and f contiguous
+	  PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	}else if(order != NPY_FORTRANORDER){//set c contiguous
+	  PyGpuNdArray_FLAGS(self) &= ~NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) |= NPY_C_CONTIGUOUS;
+	}else{//set f contiguous
+	  PyGpuNdArray_FLAGS(self) |= NPY_F_CONTIGUOUS;
+	  PyGpuNdArray_FLAGS(self) &= ~NPY_C_CONTIGUOUS;
+	}
+	PyGpuNdArray_FLAGS(self) &= ~NPY_UPDATEIFCOPY;
+        return 0;
+    }else{
+      // How to check for the flags? Need to check if already contiguous.
+      PyErr_Format(PyExc_RuntimeError,
+		   "PyGpuNdArray_alloc_contiguous: self->data_allocated=%d, size=%d, cmp=%d",
+		   self->data_allocated, size, self->data_allocated != size
+		   );
+      return -1;
+    }
+
+    if (order != NPY_FORTRANORDER) {
+        assert(PyGpuNdArray_is_c_contiguous(self));
+    } else {
+        assert(PyGpuNdArray_is_f_contiguous(self));
+    }
+    DPRINTF("PyGpuNdArray_alloc_contiguous: end\n");
+    return 0;
+}
+
+enum PyGpuTransfert { PyGpuHostToDevice, PyGpuDeviceToHost };
+int PyGpuMemcpy(void * dst, const void * src, int dev_offset, size_t bytes, PyGpuTransfert direction);
+
+int PyGpuMemset(void * dst, int data, size_t bytes);
+#endif