cimport libc.stdio

from libc.stdlib cimport malloc, calloc, free

from cpython.mem cimport PyMem_Malloc, PyMem_Free

from libc.string cimport strncmp

cimport numpy as np

import numpy as np

import sys

from cpython cimport Py_INCREF, PyNumber_Index

from cpython.object cimport Py_EQ, Py_NE

def api_version():

"""api_version()

"""

# (library version, module version)

return (GPUARRAY_API_VERSION, 0)

def abi_version():

"""abi_version()

"""

major_version = GPUARRAY_ABI_VERSION / 1000

minor_version = GPUARRAY_ABI_VERSION % 1000

return (major_version, minor_version)

np.import_array()

# to export the numeric value

SIZE = GA_SIZE

SSIZE = GA_SSIZE

# Numpy API steals dtype references and this breaks cython

cdef object PyArray_Empty(int a, np.npy_intp *b, np.dtype c, int d):

Py_INCREF(c)

return _PyArray_Empty(a, b, c, d)

cdef bytes _s(s):

if isinstance(s, unicode):

return (<unicode>s).encode('ascii')

if isinstance(s, bytes):

return s

raise TypeError("Expected a string")

cdef size_t countis(l, object val):

cdef size_t count

cdef size_t i

count = 0

for i in range(len(l)):

if l[i] is val:

count += 1

return count

def cl_wrap_ctx(size_t ptr):

"""

cl_wrap_ctx(ptr)

Wrap an existing OpenCL context (the cl_context struct) into a

GpuContext class.

"""

cdef gpucontext *(*cl_make_ctx)(void *, int)

cdef GpuContext res

cl_make_ctx = <gpucontext *(*)(void *, int)>gpuarray_get_extension("cl_make_ctx")

if cl_make_ctx == NULL:

raise RuntimeError, "cl_make_ctx extension is absent"

res = GpuContext.__new__(GpuContext)

res.ctx = cl_make_ctx(<void *>ptr, 0)

if res.ctx == NULL:

raise RuntimeError, "cl_make_ctx call failed"

return res

def cuda_wrap_ctx(size_t ptr, bint own):

"""

cuda_wrap_ctx(ptr)

Wrap an existing CUDA driver context (CUcontext) into a GpuContext

class.

If `own` is true, libgpuarray is now reponsible for the context and

it will be destroyed once there are no references to it.

Otherwise, the context will not be destroyed and it is the calling

code's reponsability.

"""

cdef gpucontext *(*cuda_make_ctx)(void *, int)

cdef int flags

cdef GpuContext res

cuda_make_ctx = <gpucontext *(*)(void *, int)>gpuarray_get_extension("cuda_make_ctx")

if cuda_make_ctx == NULL:

raise RuntimeError, "cuda_make_ctx extension is absent"

res = GpuContext.__new__(GpuContext)

flags = 0

if not own:

flags |= GPUARRAY_CUDA_CTX_NOFREE

res.ctx = cuda_make_ctx(<void *>ptr, flags)

if res.ctx == NULL:

raise RuntimeError, "cuda_make_ctx call failed"

return res

import numpy

cdef dict NP_TO_TYPE = {

np.dtype('bool'): GA_BOOL,

np.dtype('int8'): GA_BYTE,

np.dtype('uint8'): GA_UBYTE,

np.dtype('int16'): GA_SHORT,

np.dtype('uint16'): GA_USHORT,

np.dtype('int32'): GA_INT,

np.dtype('uint32'): GA_UINT,

np.dtype('int64'): GA_LONG,

np.dtype('uint64'): GA_ULONG,

np.dtype('float32'): GA_FLOAT,

np.dtype('float64'): GA_DOUBLE,

np.dtype('complex64'): GA_CFLOAT,

np.dtype('complex128'): GA_CDOUBLE,

np.dtype('float16'): GA_HALF,

}

cdef dict TYPE_TO_NP = dict((v, k) for k, v in NP_TO_TYPE.iteritems())

def register_dtype(np.dtype dtype, cname):

"""

register_dtype(dtype, cname)

Make a new type known to the cluda machinery.

This function return the associted internal typecode for the new

type.

Parameters

----------

dtype: numpy.dtype

new type

cname: str

C name for the type declarations

"""

cdef gpuarray_type *t

cdef int typecode

cdef char *tmp

t = <gpuarray_type *>malloc(sizeof(gpuarray_type))

if t == NULL:

raise MemoryError, "Can't allocate new type"

tmp = <char *>malloc(len(cname)+1)

if tmp == NULL:

free(t)

raise MemoryError

memcpy(tmp, <char *>cname, len(cname)+1)

t.size = dtype.itemsize

t.align = dtype.alignment

t.cluda_name = tmp

typecode = gpuarray_register_type(t, NULL)

if typecode == -1:

free(tmp)

free(t)

raise RuntimeError, "Could not register type"

NP_TO_TYPE[dtype] = typecode

TYPE_TO_NP[typecode] = dtype

cdef np.dtype typecode_to_dtype(int typecode):

res = TYPE_TO_NP.get(typecode, None)

if res is not None:

return res

else:

raise NotImplementedError, "TODO"

# This function takes a flexible dtype as accepted by the functions of

# this module and ensures it becomes a numpy dtype.

cdef np.dtype dtype_to_npdtype(dtype):

if dtype is None:

return None

if isinstance(dtype, int):

return typecode_to_dtype(dtype)

try:

return np.dtype(dtype)

except TypeError:

pass

if isinstance(dtype, np.dtype):

return dtype

raise ValueError("data type not understood", dtype)

# This is a stupid wrapper to avoid the extra argument introduced by having

# dtype_to_typecode declared 'cpdef'.

cdef int get_typecode(dtype) except -1:

return dtype_to_typecode(dtype)

cpdef int dtype_to_typecode(dtype) except -1:

"""

dtype_to_typecode(dtype)

Get the internal typecode for a type.

Parameters

----------

dtype: numpy.dtype

type to get the code for

"""

if isinstance(dtype, int):

return dtype

try:

dtype = np.dtype(dtype)

except TypeError:

pass

if isinstance(dtype, np.dtype):

res = NP_TO_TYPE.get(dtype, None)

if res is not None:

return res

raise ValueError, "don't know how to convert to dtype: %s"%(dtype,)

def dtype_to_ctype(dtype):

"""

dtype_to_ctype(dtype)

Return the C name for a type.

Parameters

----------

dtype: numpy.dtype

type to get the name for

"""

cdef int typecode = dtype_to_typecode(dtype)

cdef const gpuarray_type *t = gpuarray_get_type(typecode)

cdef bytes res

if t.cluda_name == NULL:

raise ValueError, "No mapping for %s"%(dtype,)

res = t.cluda_name

return res.decode('ascii')

cdef ga_order to_ga_order(ord) except <ga_order>-2:

if ord == "C" or ord == "c":

return GA_C_ORDER

elif ord == "A" or ord == "a" or ord is None:

return GA_ANY_ORDER

elif ord == "F" or ord == "f":

return GA_F_ORDER

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 = <ssize_t>(strides[i]) * <ssize_t>(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 < <size_t>(-max_axis_offset):

return 0

lower += max_axis_offset

return (upper + itemsize) <= size

class GpuArrayException(Exception):

"""

Exception used for most errors related to libgpuarray.

"""

class UnsupportedException(GpuArrayException):

pass

cdef type get_exc(int errcode):

if errcode == GA_VALUE_ERROR:

return ValueError

if errcode == GA_DEVSUP_ERROR:

return UnsupportedException

else:

return GpuArrayException

cdef bint py_CHKFLAGS(GpuArray a, int flags):

return GpuArray_CHKFLAGS(&a.ga, 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:

cdef int err

err = GpuArray_empty(&a.ga, ctx, typecode, nd, dims, ord)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(ctx, err)

cdef int array_fromdata(GpuArray a,

gpudata *data, size_t offset, int typecode,

unsigned int nd, const size_t *dims,

const ssize_t *strides, int writeable) except -1:

cdef int err

err = GpuArray_fromdata(&a.ga, data, offset, typecode, nd, dims,

strides, writeable)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(gpudata_context(data), err)

cdef int array_view(GpuArray v, GpuArray a) except -1:

cdef int err

err = GpuArray_view(&v.ga, &a.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_sync(GpuArray a) except -1:

cdef int err

with nogil:

err = GpuArray_sync(&a.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_index(GpuArray r, GpuArray a, const ssize_t *starts,

const ssize_t *stops, const ssize_t *steps) except -1:

cdef int err

err = GpuArray_index(&r.ga, &a.ga, starts, stops, steps)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_take1(GpuArray r, GpuArray a, GpuArray i,

int check_err) except -1:

cdef int err

err = GpuArray_take1(&r.ga, &a.ga, &i.ga, check_err)

if err != GA_NO_ERROR:

if err == GA_VALUE_ERROR:

raise IndexError, GpuArray_error(&r.ga, err)

raise get_exc(err), GpuArray_error(&r.ga, err)

cdef int array_setarray(GpuArray v, GpuArray a) except -1:

cdef int err

err = GpuArray_setarray(&v.ga, &a.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&v.ga, err)

cdef int array_reshape(GpuArray res, GpuArray a, unsigned int nd,

const size_t *newdims, ga_order ord,

bint nocopy) except -1:

cdef int err

err = GpuArray_reshape(&res.ga, &a.ga, nd, newdims, ord, nocopy)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_transpose(GpuArray res, GpuArray a,

const unsigned int *new_axes) except -1:

cdef int err

err = GpuArray_transpose(&res.ga, &a.ga, new_axes)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_clear(GpuArray a) except -1:

GpuArray_clear(&a.ga)

cdef bint array_share(GpuArray a, GpuArray b):

return GpuArray_share(&a.ga, &b.ga)

cdef gpucontext *array_context(GpuArray a) except NULL:

cdef gpucontext *res

res = GpuArray_context(&a.ga)

if res is NULL:

raise GpuArrayException, "Invalid array or destroyed context"

return res

cdef int array_move(GpuArray a, GpuArray src) except -1:

cdef int err

err = GpuArray_move(&a.ga, &src.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_write(GpuArray a, void *src, size_t sz) except -1:

cdef int err

with nogil:

err = GpuArray_write(&a.ga, src, sz)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_read(void *dst, size_t sz, GpuArray src) except -1:

cdef int err

with nogil:

err = GpuArray_read(dst, sz, &src.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&src.ga, err)

cdef int array_memset(GpuArray a, int data) except -1:

cdef int err

err = GpuArray_memset(&a.ga, data)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_copy(GpuArray res, GpuArray a, ga_order order) except -1:

cdef int err

err = GpuArray_copy(&res.ga, &a.ga, order)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_transfer(GpuArray res, GpuArray a) except -1:

cdef int err

with nogil:

err = GpuArray_transfer(&res.ga, &a.ga)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_split(_GpuArray **res, GpuArray a, size_t n, size_t *p,

unsigned int axis) except -1:

cdef int err

err = GpuArray_split(res, &a.ga, n, p, axis)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(&a.ga, err)

cdef int array_concatenate(GpuArray r, const _GpuArray **a, size_t n,

unsigned int axis, int restype) except -1:

cdef int err

err = GpuArray_concatenate(&r.ga, a, n, axis, restype)

if err != GA_NO_ERROR:

raise get_exc(err), GpuArray_error(a[0], err)

cdef const char *kernel_error(GpuKernel k, int err) except NULL:

return gpucontext_error(gpukernel_context(k.k.k), err)

cdef int kernel_init(GpuKernel k, gpucontext *ctx,

unsigned int count, const char **strs, const size_t *len,

const char *name, unsigned int argcount, const int *types,

int flags) except -1:

cdef int err

cdef char *err_str = NULL

err = GpuKernel_init(&k.k, ctx, count, strs, len, name, argcount,

types, flags, &err_str)

if err != GA_NO_ERROR:

if err_str != NULL:

try:

py_err_str = err_str.decode('UTF-8')

finally:

free(err_str)

raise get_exc(err), py_err_str

raise get_exc(err), gpucontext_error(ctx, err)

cdef int kernel_clear(GpuKernel k) except -1:

GpuKernel_clear(&k.k)

cdef gpucontext *kernel_context(GpuKernel k) except NULL:

cdef gpucontext *res

res = GpuKernel_context(&k.k)

if res is NULL:

raise GpuArrayException, "Invalid kernel or destroyed context"

return res

cdef int kernel_sched(GpuKernel k, size_t n, size_t *gs, size_t *ls) except -1:

cdef int err

err = GpuKernel_sched(&k.k, n, gs, ls)

if err != GA_NO_ERROR:

raise get_exc(err), kernel_error(k, err)

cdef int kernel_call(GpuKernel k, unsigned int n, const size_t *gs,

const size_t *ls, size_t shared, void **args) except -1:

cdef int err

err = GpuKernel_call(&k.k, n, gs, ls, shared, args)

if err != GA_NO_ERROR:

raise get_exc(err), kernel_error(k, err)

cdef int kernel_property(GpuKernel k, int prop_id, void *res) except -1:

cdef int err

err = gpukernel_property(k.k.k, prop_id, res)

if err != GA_NO_ERROR:

raise get_exc(err), kernel_error(k, err)

cdef GpuContext pygpu_default_context():

return default_context

cdef GpuContext default_context = None

cdef int ctx_property(GpuContext c, int prop_id, void *res) except -1:

cdef int err

err = gpucontext_property(c.ctx, prop_id, res)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(c.ctx, err)

def set_default_context(GpuContext ctx):

"""

set_default_context(ctx)

Set the default context for the module.

The provided context will be used as a default value for all the

other functions in this module which take a context as parameter.

Call with `None` to clear the default value.

If you don't call this function the context of all other functions

is a mandatory argument.

This can be helpful to reduce clutter when working with only one

context. It is strongly discouraged to use this function when

working with multiple contexts at once.

Parameters

----------

ctx: GpuContext

default context

"""

global default_context

default_context = ctx

def get_default_context():

"""

get_default_context()

Return the currently defined default context (or `None`).

"""

return default_context

cdef GpuContext ensure_context(GpuContext c):

global default_context

if c is None:

if default_context is None:

raise TypeError, "No context specified."

return default_context

return c

cdef bint pygpu_GpuArray_Check(object o):

return isinstance(o, GpuArray)

def count_platforms(kind):

"""

count_platforms(kind)

Return number of host's platforms compatible with `kind`.

"""

cdef unsigned int platcount

cdef int err

err = gpu_get_platform_count(_s(kind), &platcount)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(NULL, err)

return platcount

def count_devices(kind, unsigned int platform):

"""

count_devices(kind, platform)

Returns number of devices in host's `platform` compatible with `kind`.

"""

cdef unsigned int devcount

cdef int err

err = gpu_get_device_count(_s(kind), platform, &devcount)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(NULL, err)

return devcount

cdef GpuContext pygpu_init(dev, gpucontext_props *p):

cdef int err

cdef GpuContext res

if dev.startswith('cuda'):

kind = b"cuda"

if dev[4:] == '':

devnum = -1

else:

devnum = int(dev[4:])

gpucontext_props_cuda_dev(p, devnum)

elif dev.startswith('opencl'):

kind = b"opencl"

devspec = dev[6:].split(':')

if len(devspec) < 2:

raise ValueError, "OpenCL name incorrect. Should be opencl<int>:<int> instead got: " + dev

if not devspec[0].isdigit() or not devspec[1].isdigit():

raise ValueError, "OpenCL name incorrect. Should be opencl<int>:<int> instead got: " + dev

else:

gpucontext_props_opencl_dev(p, int(devspec[0]), int(devspec[1]))

else:

raise ValueError, "Unknown device format:" + dev

res = GpuContext.__new__(GpuContext)

res.kind = kind

err = gpucontext_init(&res.ctx, <char *>res.kind, p)

if err != GA_NO_ERROR:

raise get_exc(err), gpucontext_error(NULL, err)

return res

def init(dev, sched='default', single_stream=False, kernel_cache_path=None,

max_cache_size=sys.maxsize, initial_cache_size=0):

"""

init(dev, sched='default', single_stream=False, kernel_cache_path=None,

max_cache_size=sys.maxsize, initial_cache_size=0)

Creates a context from a device specifier.

Device specifiers are composed of the type string and the device

id like so::

"cuda0"

"opencl0:1"

For cuda the device id is the numeric identifier. You can see

what devices are available by running nvidia-smi on the machine.

Be aware that the ordering in nvidia-smi might not correspond to

the ordering in this library. This is due to how cuda enumerates

devices. If you don't specify a number (e.g. 'cuda') the first

available device will be selected according to the backend order.

For opencl the device id is the platform number, a colon (:) and

the device number. There are no widespread and/or easy way to

list available platforms and devices. You can experiement with

the values, unavaiable ones will just raise an error, and there

are no gaps in the valid numbers.

Parameters

----------

dev: str

device specifier

sched: {'default', 'single', 'multi'}

optimize scheduling for which type of operation

disable_alloc_cache: bool

disable allocation cache (if any)

single_stream: bool

enable single stream mode

"""

cdef gpucontext_props *p = NULL

cdef int err

cdef bytes kernel_cache_path_b

err = gpucontext_props_new(&p)

if err != GA_NO_ERROR:

raise MemoryError

try:

if sched == 'single':

gpucontext_props_sched(p, GA_CTX_SCHED_SINGLE)

elif sched == 'multi':

gpucontext_props_sched(p, GA_CTX_SCHED_MULTI)

elif sched != 'default':

raise TypeError('unexpected value for parameter sched: %s' % (sched,))

if kernel_cache_path:

kernel_cache_path_b = _s(kernel_cache_path)

gpucontext_props_kernel_cache(p, <const char *>kernel_cache_path_b)

gpucontext_props_alloc_cache(p, initial_cache_size, max_cache_size)

if single_stream:

gpucontext_props_set_single_stream(p);

except:

gpucontext_props_del(p)

raise

return pygpu_init(dev, p)

def zeros(shape, dtype=GA_DOUBLE, order='C', GpuContext context=None,

cls=None):

"""

zeros(shape, dtype='float64', order='C', context=None, cls=None)

Returns an array of zero-initialized values of the requested

shape, type and order.

Parameters

----------

shape: iterable of ints

number of elements in each dimension

dtype: str, numpy.dtype or int

type of the elements

order: {'A', 'C', 'F'}

layout of the data in memory, one of 'A'ny, 'C' or 'F'ortran

context: GpuContext

context in which to do the allocation

cls: type

class of the returned array (must inherit from GpuArray)

"""

res = empty(shape, dtype=dtype, order=order, context=context, cls=cls)

array_memset(res, 0)

return res

cdef GpuArray pygpu_zeros(unsigned int nd, const size_t *dims, int typecode,

ga_order order, GpuContext context, object cls):

cdef GpuArray res

res = pygpu_empty(nd, dims, typecode, order, context, cls)

array_memset(res, 0)

return res

cdef GpuArray pygpu_empty(unsigned int nd, const size_t *dims, int typecode,

ga_order order, GpuContext context, object cls):

cdef GpuArray res

context = ensure_context(context)

res = new_GpuArray(cls, context, None)

array_empty(res, context.ctx, typecode, nd, dims, order)

return res

cdef GpuArray pygpu_fromgpudata(gpudata *buf, size_t offset, int typecode,

unsigned int nd, const size_t *dims,

const ssize_t *strides, GpuContext context,

bint writable, object base, object cls):

cdef GpuArray res

res = new_GpuArray(cls, context, base)

array_fromdata(res, buf, offset, typecode, nd, dims,

strides, writable)

return res

cdef GpuArray pygpu_copy(GpuArray a, ga_order ord):

cdef GpuArray res

res = new_GpuArray(type(a), a.context, None)

array_copy(res, a, ord)

return res

cdef int pygpu_move(GpuArray a, GpuArray src) except -1:

array_move(a, src)

return 0

def empty(shape, dtype=GA_DOUBLE, order='C', GpuContext context=None,

cls=None):

"""

empty(shape, dtype='float64', order='C', context=None, cls=None)

Returns an empty (uninitialized) array of the requested shape,

type and order.

Parameters

----------

shape: iterable of ints

number of elements in each dimension

dtype: str, numpy.dtype or int

type of the elements

order: {'A', 'C', 'F'}

layout of the data in memory, one of 'A'ny, 'C' or 'F'ortran

context: GpuContext

context in which to do the allocation

cls: type

class of the returned array (must inherit from GpuArray)

"""

cdef size_t *cdims

cdef unsigned int nd

try:

nd = <unsigned int>len(shape)

except TypeError:

nd = 1

shape = [shape]

cdims = <size_t *>calloc(nd, sizeof(size_t))

if cdims == NULL:

raise MemoryError, "could not allocate cdims"

try:

for i, d in enumerate(shape):

cdims[i] = d

return pygpu_empty(nd, cdims,

dtype_to_typecode(dtype), to_ga_order(order),

context, cls)

finally:

free(cdims)

def asarray(a, dtype=None, order='A', GpuContext context=None):

"""

asarray(a, dtype=None, order='A', context=None)

Returns a GpuArray from the data in `a`

If `a` is already a GpuArray and all other parameters match, then

the object itself returned. If `a` is an instance of a subclass

of GpuArray then a view of the base class will be returned.

Otherwise a new object is create and the data is copied into it.

`context` is optional if `a` is a GpuArray (but must match exactly

the context of `a` if specified) and is mandatory otherwise.

Parameters

----------

a: array-like

data

dtype: str, numpy.dtype or int

type of the elements

order: {'A', 'C', 'F'}

layout of the data in memory, one of 'A'ny, 'C' or 'F'ortran

context: GpuContext

context in which to do the allocation

"""

return array(a, dtype=dtype, order=order, copy=False, context=context,

cls=GpuArray)

def ascontiguousarray(a, dtype=None, GpuContext context=None):

"""

ascontiguousarray(a, dtype=None, context=None)

Returns a contiguous array in device memory (C order).

`context` is optional if `a` is a GpuArray (but must match exactly

the context of `a` if specified) and is mandatory otherwise.

Parameters

----------

a: array-like

input

dtype: str, numpy.dtype or int

type of the return array

context: GpuContext

context to use for a new array

"""

return array(a, order='C', dtype=dtype, ndmin=1, copy=False,

context=context)

def asfortranarray(a, dtype=None, GpuArray context=None):

"""

asfortranarray(a, dtype=None, context=None)

Returns a contiguous array in device memory (Fortran order)

`context` is optional if `a` is a GpuArray (but must match exactly

the context of `a` if specified) and is mandatory otherwise.

Parameters

----------

a: array-like

input

dtype: str, numpy.dtype or int

type of the elements

context: GpuContext

context in which to do the allocation

"""

return array(a, order='F', dtype=dtype, ndmin=1, copy=False,

context=context)

def may_share_memory(GpuArray a not None, GpuArray b not None):

"""

may_share_memory(a, b)

Returns True if `a` and `b` may share memory, False otherwise.

"""

return array_share(a, b)

def from_gpudata(size_t data, offset, dtype, shape, GpuContext context=None,

strides=None, writable=True, base=None, cls=None):

"""

from_gpudata(data, offset, dtype, shape, context=None, strides=None, writable=True, base=None, cls=None)

Build a GpuArray from pre-allocated gpudata

Parameters

----------

data: int

pointer to a gpudata structure

offset: int

offset to the data location inside the gpudata

dtype: numpy.dtype

data type of the gpudata elements

shape: iterable of ints

shape to use for the result

context: GpuContext

context of the gpudata

strides: iterable of ints

strides for the results (C contiguous if not specified)

writable: bool

is the data writable?

base: object

base object that keeps gpudata alive

cls: type

view type of the result

Notes

-----

This function might be deprecated in a later relase since the only

way to create gpudata pointers is through libgpuarray functions

that aren't exposed at the python level. It can be used with the

value of the `gpudata` attribute of an existing GpuArray.

.. warning::

This function is intended for advanced use and will crash the

interpreter if used improperly.

"""

cdef size_t *cdims = NULL

cdef ssize_t *cstrides = NULL

cdef unsigned int nd

cdef size_t size

cdef int typecode

context = ensure_context(context)

try:

nd = <unsigned int>len(shape)

except TypeError:

nd = 1

shape = [shape]

if strides is not None and len(strides) != nd:

raise ValueError, "strides must be the same length as shape"

typecode = dtype_to_typecode(dtype)

try:

cdims = <size_t *>calloc(nd, sizeof(size_t))

cstrides = <ssize_t *>calloc(nd, sizeof(ssize_t))

if cdims == NULL or cstrides == NULL:

raise MemoryError

for i, d in enumerate(shape):

cdims[i] = d

if strides:

for i, s in enumerate(strides):

cstrides[i] = s

else:

size = gpuarray_get_elsize(typecode)

for i in range(nd-1, -1, -1):

cstrides[i] = size

size *= cdims[i]

return pygpu_fromgpudata(<gpudata *>data, offset, typecode, nd, cdims,

cstrides, context, writable, base, cls)

finally:

free(cdims)

free(cstrides)

def array(proto, dtype=None, copy=True, order=None, unsigned int ndmin=0,

GpuContext context=None, cls=None):

"""

array(obj, dtype='float64', copy=True, order=None, ndmin=0, context=None, cls=None)

Create a GpuArray from existing data

This function creates a new GpuArray from the data provided in

`obj` except if `obj` is already a GpuArray and all the parameters

match its properties and `copy` is False.

The properties of the resulting array depend on the input data

except if overriden by other parameters.

This function is similar to :meth:`numpy.array` except that it returns

GpuArrays.

Parameters

----------

obj: array-like

data to initialize the result

dtype: string or numpy.dtype or int

data type of the result elements

copy: bool

return a copy?

order: str

memory layout of the result

ndmin: int

minimum number of result dimensions

context: GpuContext

allocation context

cls: type

result class (must inherit from GpuArray)

"""

return carray(proto, dtype, copy, order, ndmin, context, cls)

cdef carray(proto, dtype, copy, order, unsigned int ndmin,

GpuContext context, cls):

cdef GpuArray res

cdef GpuArray arg

cdef GpuArray tmp

cdef np.ndarray a

if isinstance(proto, GpuArray):

arg = proto

if context is not None and context.ctx != array_context(arg):

raise ValueError, "cannot copy an array to a different context"

if (not copy

and (dtype is None or dtype_to_typecode(dtype) == arg.typecode)

and (order is None or order == 'A' or

(order == 'C' and py_CHKFLAGS(arg, GA_C_CONTIGUOUS)) or

(order == 'F' and py_CHKFLAGS(arg, GA_F_CONTIGUOUS)))):

if arg.ga.nd < ndmin:

shp = arg.shape

idx = (1,)*(ndmin-len(shp))

shp = idx + shp

arg = arg.reshape(shp)

if not (cls is None or arg.__class__ is cls):

arg = arg.view(cls)

return arg

shp = arg.shape

if len(shp) < ndmin:

idx = (1,)*(ndmin-len(shp))

shp = idx + shp

if order is None or order == 'A':

if py_CHKFLAGS(arg, GA_C_CONTIGUOUS):

order = 'C'

elif py_CHKFLAGS(arg, GA_F_CONTIGUOUS):

order = 'F'

if cls is None:

cls = type(proto)

res = empty(shp, dtype=(dtype or arg.dtype), order=order, cls=cls,

context=arg.context)

res.base = arg.base