pyopencl 2024.2.7__cp38-cp38-win_amd64.whl → 2024.3__cp38-cp38-win_amd64.whl

pyopencl/compyte/ndarray/pygpu_ndarray.h

@@ -1,71 +0,0 @@
-#ifndef _PYGPU_NDARRAY_H
-#define _PYGPU_NDARRAY_H
-#ifndef OFFSET
-#define OFFSET 0
-#endif
-
-//#include <Python.h>
-//#include <structmember.h>
-#include <stdio.h>
-#include <numpy/arrayobject.h>
-
-#include "pygpu_ndarray_object.h"
-#include "gpu_ndarray.h"
-#include "pygpu_language.h"
-
-/*
- * Return a PyGpuNdArray whose 'nd' dimensions are all 0.
- * if nd==-1, it is not initialized.
- */
-PyObject * PyGpuNdArray_New(int nd=-1);
-
-/**
- * Return 1 for a PyGpuNdArrayObject otw 0
- */
-int 
-PyGpuNdArray_Check(const PyObject * ob);
-
-/**
- * Return 1 for a PyGpuNdArrayObject otw 0
- */
-int 
-PyGpuNdArray_CheckExact(const PyObject * ob);
-
-/**
- * Transfer the contents of numpy array `obj` to `self`.
- *
- * self is reallocated to have the correct dimensions if necessary.
- */
-int PyGpuNdArray_CopyFromArray(PyGpuNdArrayObject * self, PyArrayObject*obj);
-
-static int 
-PyGpuNdArray_add_offset(PyGpuNdArrayObject * self, int offset);
-
-static int 
-PyGpuNdArray_set_data(PyGpuNdArrayObject * self, char * data, PyObject * base, int offset=0);
-
-static PyObject *
-PyGpuNdArray_Subscript(PyObject * py_self, PyObject * key);
-
-static PyObject *
-PyGpuNdArray_Copy(PyGpuNdArrayObject * self, NPY_ORDER order=NPY_CORDER);
-
-static PyObject *
-PyGpuNdArray_Zeros(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran);
-
-static PyObject *
-PyGpuNdArray_Empty(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran);
-
-#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_ndarray_object.h

@@ -1,232 +0,0 @@
-/**
- * struct PyGPUArrayObject
- *
- * This is a Python type.  
- *
- */
-#ifndef _PYGPU_NDARRAY_OBJECT_H
-#define _PYGPU_NDARRAY_OBJECT_H
-
-#include <Python.h>
-#include <numpy/arrayobject.h>
-#include "gpu_ndarray.h"
-
-typedef struct PyGpuNdArrayObject{
-  PyObject_HEAD
-
-  GpuNdArray gpu_ndarray; //no pointer, just inlined.
-  PyObject * base;
-  PyArray_Descr * descr; // for numpy-like desc
-  int data_allocated; //the number of bytes allocated for devdata
-} PyGpuNdArrayObject;
-
-#define PyGpuNdArray_NDIM(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.nd)
-#define PyGpuNdArray_DATA(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.data)
-#define PyGpuNdArray_BYTES(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.data)
-#define PyGpuNdArray_OFFSET(obj) (((PyGpuNdArrayObject *)(obj))->gpu_ndarray.offset)
-#define PyGpuNdArray_DIMS(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.dimensions)
-#define PyGpuNdArray_STRIDES(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.strides)
-#define PyGpuNdArray_DIM(obj,n) (PyGpuNdArray_DIMS(obj)[n])
-#define PyGpuNdArray_STRIDE(obj,n) (PyGpuNdArray_STRIDES(obj)[n])
-#define PyGpuNdArray_BASE(obj) (((PyGpuNdArrayObject *)obj)->base)
-#define PyGpuNdArray_DESCR(obj) (((PyGpuNdArrayObject *)obj)->descr)
-#define PyGpuNdArray_FLAGS(obj) (((PyGpuNdArrayObject *)obj)->gpu_ndarray.flags)
-#define PyGpuNdArray_ITEMSIZE(obj) (((PyGpuNdArrayObject *)obj)->descr->elsize)
-#define PyGpuNdArray_TYPE(obj) (((PyGpuNdArrayObject *)(obj))->descr->type_num)
-
-#define PyGpuNdArray_SIZE(obj) PyArray_MultiplyList(PyGpuNdArray_DIMS(obj),PyGpuNdArray_NDIM(obj))
-//npy_intp PyGpuNdArray_Size(PyObject* obj);
-//npy_intp PyGpuNdArray_NBYTES(PyObject* arr);
-
-/*
-  Flags accessor
- */
-#define PyGpuNdArray_CHKFLAGS(m, FLAGS)                              \
-        ((((PyGpuNdArrayObject *)(m))->gpu_ndarray.flags & (FLAGS)) == (FLAGS))
-
-#define PyGpuNdArray_ISCONTIGUOUS(m) PyGpuNdArray_CHKFLAGS(m, NPY_CONTIGUOUS)
-#define PyGpuNdArray_ISFORTRAN(m) (PyGpuNdArray_CHKFLAGS(m, NPY_F_CONTIGUOUS) && \
-                                   PyGpuNdArray_NDIM(m) > 1)
-#define PyGpuNdArray_FORTRAN_IF(m) (PyGpuNdArray_CHKFLAGS(m, NPY_F_CONTIGUOUS)? \
-                                    NPY_F_CONTIGUOUS : 0)
-#define PyGpuNdArray_ISONESEGMENT(m) (PyGpuNdArray_NDIM(m) == 0 || \
-                                      PyGpuNdArray_ISCONTIGUOUS(m) || \
-                                      PyGpuNdArray_ISFORTRAN(m))
-#define PyGpuNdArray_ISWRITEABLE(m) PyGpuNdArray_CHKFLAGS(m, NPY_WRITEABLE)
-#define PyGpuNdArray_ISALIGNED(m) PyGpuNdArray_CHKFLAGS(m, NPY_ALIGNED)
-
-#define PyGpuNdArray_ISNBO(arg) ((arg) != NPY_OPPBYTE)
-// THE NEXT ONE SEEM BAD...
-#define PyGpuNdArray_IsNativeByteOrder PyArray_ISNBO
-#define PyGpuNdArray_ISNOTSWAPPED(m) PyArray_ISNBO(PyArray_DESCR(m)->byteorder)
-#define PyGpuNdArray_FLAGSWAP(m, flags) (PyGpuNdArray_CHKFLAGS(m, flags) && PyGpuNdArray_ISNOTSWAPPED(m))
-
-#define PyGpuNdArray_ISCARRAY(m) PyGpuNdArray_FLAGSWAP(m, NPY_CARRAY)
-#define PyGpuNdArray_ISCARRAY_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_CARRAY_RO)
-#define PyGpuNdArray_ISFARRAY(m) PyGpuNdArray_FLAGSWAP(m, NPY_FARRAY)
-#define PyGpuNdArray_ISFARRAY_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_FARRAY_RO)
-#define PyGpuNdArray_ISBEHAVED(m) PyGpuNdArray_FLAGSWAP(m, NPY_BEHAVED)
-#define PyGpuNdArray_ISBEHAVED_RO(m) PyGpuNdArray_FLAGSWAP(m, NPY_ALIGNED)
-
-static
-void PyGpuNdArray_fprint(FILE * fd, const PyGpuNdArrayObject *self)
-{
-    fprintf(fd, "PyGpuNdArrayObject <%p, %p> nd=%i data_allocated=%d\n",
-	    self, PyGpuNdArray_DATA(self), PyGpuNdArray_NDIM(self), self->data_allocated);
-    fprintf(fd, "\tITEMSIZE: %d\n", PyGpuNdArray_ITEMSIZE(self));
-    fprintf(fd, "\tTYPENUM: %d\n", PyGpuNdArray_TYPE(self));
-    fprintf(fd, "\tRefcount: %ld\n", (long int)self->ob_refcnt);
-    fprintf(fd, "\tBASE: %p\n", PyGpuNdArray_BASE(self));
-    fprintf(fd, "\tHOST_DIMS:      ");
-    for (int i = 0; i < PyGpuNdArray_NDIM(self); ++i)
-    {
-        fprintf(fd, "%ld\t", PyGpuNdArray_DIMS(self)[i]);
-    }
-    fprintf(fd, "\n\tHOST_STRIDES: ");
-    for (int i = 0; i < PyGpuNdArray_NDIM(self); ++i)
-    {
-        fprintf(fd, "%ld\t", PyGpuNdArray_STRIDES(self)[i]);
-    }
-    fprintf(fd, "\n\tFLAGS: ");
-    fprintf(fd, "\n\t\tC_CONTIGUOUS: %d", PyGpuNdArray_ISCONTIGUOUS(self));
-    fprintf(fd, "\n\t\tPyGpuNdArray_ISFORTRAN: %d PyGpuNdArray_FORTRAN_IF:%d F_CONTIGUOUS: %d",
-            PyGpuNdArray_ISFORTRAN(self), PyGpuNdArray_FORTRAN_IF(self), PyGpuNdArray_CHKFLAGS(self, NPY_FORTRAN));
-    fprintf(fd, "\n\t\tOWNDATA: %d", PyGpuNdArray_CHKFLAGS(self, NPY_OWNDATA));
-    fprintf(fd, "\n\t\tWRITEABLE: %d", PyGpuNdArray_ISWRITEABLE(self));
-    fprintf(fd, "\n\t\tALIGNED: %d", PyGpuNdArray_ISALIGNED(self));
-    fprintf(fd, "\n\t\tUPDATEIFCOPY: %d", PyGpuNdArray_CHKFLAGS(self, NPY_UPDATEIFCOPY));
-    fprintf(fd, "\n");
-
-}
-static
-void PyArray_fprint(FILE * fd, const PyArrayObject *self)
-{
-    fprintf(fd, "PyArrayObject <%p, %p> nd=%i\n",
-	    self, PyArray_DATA(self), PyArray_NDIM(self));
-    fprintf(fd, "\tITEMSIZE: %d\n", PyArray_ITEMSIZE(self));
-    fprintf(fd, "\tTYPENUM: %d\n", PyArray_TYPE(self));
-    fprintf(fd, "\tHOST_DIMS:      ");
-    for (int i = 0; i < PyArray_NDIM(self); ++i)
-    {
-        fprintf(fd, "%ld\t", PyArray_DIMS(self)[i]);
-    }
-    fprintf(fd, "\n\tHOST_STRIDES: ");
-    for (int i = 0; i < PyArray_NDIM(self); ++i)
-    {
-        fprintf(fd, "%ld\t", PyArray_STRIDES(self)[i]);
-    }
-    fprintf(fd, "\n\tFLAGS: ");
-    fprintf(fd, "\n\t\tC_CONTIGUOUS: %d", PyArray_ISCONTIGUOUS(self));
-    fprintf(fd, "\n\t\tPyArray_ISFORTRAN: %d PyArray_FORTRAN_IF:%d F_CONTIGUOUS: %d",
-            PyArray_ISFORTRAN(self), PyArray_FORTRAN_IF(self), PyArray_CHKFLAGS(self, NPY_FORTRAN));
-    fprintf(fd, "\n\t\tOWNDATA: %d", PyArray_CHKFLAGS(self, NPY_OWNDATA));
-    fprintf(fd, "\n\t\tWRITEABLE: %d", PyArray_ISWRITEABLE(self));
-    fprintf(fd, "\n\t\tALIGNED: %d", PyArray_ISALIGNED(self));
-    fprintf(fd, "\n\t\tUPDATEIFCOPY: %d", PyArray_CHKFLAGS(self, NPY_UPDATEIFCOPY));
-    fprintf(fd, "\n");
-
-}
-
-template <typename T>
-static T ceil_intdiv(T a, T b)
-{
-    return (a/b) + ((a % b) ? 1: 0);
-}
-
-
-//Compute if the resulting array is c contiguous
-static bool
-PyGpuNdArray_is_c_contiguous(const PyGpuNdArrayObject * self)
-{
-    bool c_contiguous = true;
-    int size = PyGpuNdArray_ITEMSIZE(self);
-    for (int i = PyGpuNdArray_NDIM(self)-1; (i >= 0) && c_contiguous; --i) {
-        if (PyGpuNdArray_STRIDE(self, i) != size) {
-            c_contiguous = false;
-        }
-        size = size * PyGpuNdArray_DIM(self, i);
-    }
-    return c_contiguous;
-}
-
-//Compute if the resulting array is f contiguous
-static bool
-PyGpuNdArray_is_f_contiguous(const PyGpuNdArrayObject * self)
-{
-    bool f_contiguous = true;
-    int size = PyGpuNdArray_ITEMSIZE(self);
-    for (int i = 0; i < PyGpuNdArray_NDIM(self) && f_contiguous; ++i) {
-        if (PyGpuNdArray_STRIDE(self, i) != size) {
-            f_contiguous = false;
-        }
-        size = size * PyGpuNdArray_DIM(self, i);
-    }
-    return f_contiguous;
-}
-
-static PyObject *
-PyGpuNdArray_as_c_contiguous(PyObject* dummy, PyObject* args, PyObject *kargs);
-static PyObject *
-PyGpuNdArray_as_f_contiguous(PyObject* dummy, PyObject* args, PyObject *kargs);
-
-/**
- * [Re]allocate a PyGpuNdArrayObject with access to 'nd' dimensions.
- *
- * Note: This does not allocate storage for data.
- */
-static
-int PyGpuNdArray_set_nd(PyGpuNdArrayObject * self, const int nd)
-{
-    if (nd != PyGpuNdArray_NDIM(self))
-    {
-        if(0) fprintf(stderr, "PyGpuNdArray_set_nd: modif nd=%i to nd=%i\n", PyGpuNdArray_NDIM(self), nd);
-    
-        if (PyGpuNdArray_DIMS(self)){
-            free(PyGpuNdArray_DIMS(self));
-            PyGpuNdArray_DIMS(self) = NULL;
-            PyGpuNdArray_NDIM(self) = -1;
-        }
-        if (PyGpuNdArray_STRIDES(self)){
-            free(PyGpuNdArray_STRIDES(self));
-            PyGpuNdArray_STRIDES(self) = NULL;
-            PyGpuNdArray_NDIM(self) = -1;
-        }
-        if (nd == -1) return 0;
-
-        PyGpuNdArray_DIMS(self) = (npy_intp*)malloc(nd*sizeof(npy_intp));
-        if (NULL == PyGpuNdArray_DIMS(self))
-        {
-            PyErr_SetString(PyExc_MemoryError, "PyGpuNdArray_set_nd: Failed to allocate dimensions");
-            return -1;
-        }
-        PyGpuNdArray_STRIDES(self) = (npy_intp*)malloc(nd*sizeof(npy_intp));
-        if (NULL == PyGpuNdArray_STRIDES(self))
-        {
-            PyErr_SetString(PyExc_MemoryError, "PyGpuNdArray_set_nd: Failed to allocate str");
-            return -1;
-        }
-        //initialize all dimensions and strides to 0
-        for (int i = 0; i < nd; ++i)
-        {
-            PyGpuNdArray_DIM(self, i) = 0;
-            PyGpuNdArray_STRIDES(self)[i] = 0;
-        }
-
-        PyGpuNdArray_NDIM(self) = nd;
-	if(0) fprintf(stderr, "PyGpuNdArray_set_nd: end\n");
-    }
-    return 0;
-}
-
-#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/setup_opencl.py

@@ -1,101 +0,0 @@
-import os
-from distutils.command.build_ext import build_ext
-from distutils.core import Extension, setup
-from distutils.dep_util import newer
-
-import numpy as np
-
-
-class build_ext_nvcc(build_ext):
-    user_options = build_ext.user_options
-    user_options.extend([
-            ('cuda-root=', None, "The cuda root directory")])
-
-    def initialize_options(self):
-        build_ext.initialize_options(self)
-        self.cuda_root = None
-
-    def finalize_options(self):
-        build_ext.finalize_options(self)
-        if self.cuda_root is None:
-            self.cuda_root = os.getenv('CUDA_ROOT', None)
-        if self.cuda_root is not None:
-            self._nvcc_bin = os.path.join(self.cuda_root, 'bin', 'nvcc')
-        else:
-            self._nvcc_bin = 'nvcc'
-
-    def cuda_process(self, source, include_args):
-        target = source + '.cpp'
-        if newer(source, target):
-            self.spawn([self._nvcc_bin, '--cuda', source, '-o', target] + \
-                           include_args)
-        return target
-
-    def cuda_extension(self, ext):
-        includes = self.distribution.include_dirs + ext.include_dirs
-        include_args = ['-I' + i for i in includes]
-        new_sources = []
-        anycuda = False
-        for src in ext.sources:
-            if src.endswith('.cu'):
-                new_sources.append(self.cuda_process(src, include_args))
-                anycuda = True
-            else:
-                new_sources.append(src)
-        if anycuda:
-            ext.sources = new_sources
-            if self.cuda_root is not None:
-                lib = os.path.join(self.cuda_root, 'lib')
-                lib64 = os.path.join(self.cuda_root, 'lib64')
-                if os.path.isdir(lib):
-                    ext.library_dirs.append(lib)
-                    ext.extra_link_args.append('-Xlinker')
-                    ext.extra_link_args.append('-rpath')
-                    ext.extra_link_args.append('-Xlinker')
-                    ext.extra_link_args.append(lib)
-                if os.path.isdir(lib64):
-                    ext.library_dirs.append(lib64)
-#                    ext.extra_link_args.append('-rpath')
-#                    ext.extra_link_args.append(lib64)
-            if 'cudart' not in ext.libraries:
-                ext.libraries.append('cudart')
-
-        if self.cuda_root:
-            include = os.path.join(self.cuda_root, 'include')
-            if os.path.isdir(include):
-                ext.extra_compile_args.append('-I' + include)
-        if os.path.isfile('/usr/lib/nvidia-current/libOpenCL.so'):
-            ext.extra_link_args.append('-L/usr/lib/nvidia-current')
-            ext.extra_link_args.append('-Xlinker')
-            ext.extra_link_args.append('-rpath')
-            ext.extra_link_args.append('-Xlinker')
-            ext.extra_link_args.append('/usr/lib/nvidia-current')
-
-    def build_extensions(self):
-        self.check_extensions_list(self.extensions)
-
-        for ext in self.extensions:
-            self.cuda_extension(ext)
-            # uncomment this + inherit from the cython version of build_ext
-            # work with cuda and cython sources
-            #ext.sources = self.cython_sources(ext.sources, ext)
-            self.build_extension(ext)
-
-import sys
-
-if sys.platform == 'darwin':
-    libcl_args = {'extra_link_args': ['-framework', 'OpenCL']}
-else:
-    libcl_args = {'libraries': ['OpenCL']}
-
-
-setup(name='compyte',
-      cmdclass={'build_ext': build_ext_nvcc},
-      include_dirs=[np.get_include(), '.'],
-      ext_modules=[Extension('pygpu_ndarray',
-                             define_macros=[('OFFSET', '1'), ('WITH_OPENCL', '')],
-                             sources=['pygpu_language_opencl.cpp',
-                                      'pygpu_ndarray.cpp'],
-                             **libcl_args)
-                   ]
-)