GPU阵列

向量类型

class pycuda.gpuarray.vec

所有CUDA支持的向量类型,例如 float3long4 可用作 numpy 此类中的数据类型。这些 numpy.dtype 实例的字段名为 xyzw 就像他们的cuda对手一样。它们既可以用于参数传递到内核,也可以用于在内核和python代码之间来回传递数据。对于每种类型,a make_type 还提供了功能(例如 make_float3(x,y,z)

这个 GPUArray 数组类

class pycuda.gpuarray.GPUArray(shape, dtype, *, allocator=None, order='C')

A numpy.ndarray 存储数据并在计算设备上执行计算的类似工作。 形状D型 工作完全一样 numpy . 中的算术方法 GPUArray 支持标量的广播。(例如) array+5 如果

分配器 是一个可调用的,当调用一个要分配的字节数的参数时,返回一个可以被转换为一个对象的对象。 int 表示新分配内存的地址。注意两个 pycuda.driver.mem_alloc()pycuda.tools.DeviceMemoryPool.alloc() 是这个接口的一个模型。

除此之外的所有论据 分配器 只应视为关键字。

gpudata

这个 pycuda.driver.DeviceAllocation 为支持此操作的内存创建的实例 GPUArray .

shape

数组中每个维度长度的元组。

dtype

这个 numpy.dtype GPU数组中的项。

size

数组中有意义的条目数。也可以通过乘以数字来计算。 shape .

mem_size

数组中存在的条目总数,包括填充。例如,由于通过 pycuda.driver.mem_alloc_pitch() .

nbytes

整个数组的大小(字节)。计算为 sizedtype.itemsize .

strides

遍历数组时要在每个维度中单步执行的字节元组。

flags

返回具有属性的对象 c_contiguousf_contiguousforc ,可用于查询类似于 numpy.ndarray.flags .

ptr

返回一 int 反映此阵列所在的设备内存中的地址。

__len__()

返回的前导维度的大小 self .

警告

此方法存在于0.93及以下版本中,但它返回的值为 size 而不是它的当前值。为了匹配而做出了改变。 numpy .

reshape(shape, order='C')

返回包含具有新形状的相同数据的数组。

ravel()

返回包含相同数据的展平数组。

view(dtype=None)

返回具有相同数据的数组视图。如果 D型 与当前数据类型不同,将重新解释内存的实际字节数。

squeeze(dtype=None)

返回已删除长度为1的数组的视图。

set(ary)

将内容转移到 numpy.ndarray 对象 ary 在设备上。

ary 必须具有与 self .

set_async(ary, stream=None)

异步传输内容 numpy.ndarray 对象 ary 在设备上,可以选择在 流动 .

ary 必须具有与 self .

get(ary=None, pagelocked=False)

转移的内容 self 进入之内 ary 或新分配的 numpy.ndarray .如果 ary 给定时,它必须具有相同的形状和数据类型。如果没有提供,则 页面锁定 指定是否为新数组分配页锁定。

在 2015.2 版更改: ary 不同的形状被弃用。

get_async(stream=None, ary=None)

转移的内容 self 进入之内 ary 或新分配的 numpy.ndarray .如果 ary 给定时,它必须具有正确的大小(不一定是形状)和数据类型。如果没有提供,则 page-locked 数组是新分配的。

copy()

2013.1 新版功能.

mul_add(self, selffac, other, otherfac, add_timer=None, stream=None):

返回 selffac*self + otherfac*other . add_timer ,如果给定,则使用 pycuda.driver.Function.prepared_timed_call() .

__add__(other)
__sub__(other)
__iadd__(other)
__isub__(other)
__neg__(other)
__mul__(other)
__div__(other)
__rdiv__(other)
__pow__(other)
__abs__()

返回A GPUArray 包含每个元素的绝对值 self .

fill(scalar, stream=None)

在数组中填充 标量 .

astype(dtype, stream=None)

返回 self 铸成 D型 .

real

返回的实际部分 selfself 如果是真的。

0.94 新版功能.

imag

返回的虚部 selfzeros_like(self) 如果是真的。

conj()

返回的复共轭 selfself 如果是真的。

bind_to_texref(texref, allow_offset=False)

Bind self to the pycuda.driver.TextureReference texref.

由于对齐要求,有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法返回此偏移量,单位为 self 的数据类型。如果 allow_offsetFalse ,此偏移量的非零值将导致引发异常。

注解

建议使用 bind_to_texref_ext() 而不是这种方法。

bind_to_texref_ext(texref, channels=1, allow_double_hack=False, allow_offset=False)

Bind self to the pycuda.driver.TextureReference texref. In addition, set the texture reference's format to match dtype and its channel count to channels. This routine also sets the texture reference's pycuda.driver.TRSF_READ_AS_INTEGER flag, if necessary.

由于对齐要求,有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法返回此偏移量,单位为 self 的数据类型。如果 allow_offsetFalse ,此偏移量的非零值将导致引发异常。

0.93 新版功能.

在撰写本文时,CUDA纹理本身不支持双精度浮点数据。为了弥补这一缺陷,PycUDA包含一个解决方案,它可以通过 True 为了允许你的双重攻击。在这种情况下,请在内核代码中使用以下代码进行纹理访问:

#include <pycuda-helpers.hpp>

texture<fp_tex_double, 1, cudaReadModeElementType> my_tex;

__global__ void f()
{
  ...
  fp_tex1Dfetch(my_tex, threadIdx.x);
  ...
}

(此解决方案在版本0.94中添加)。

构造 GPUArray 实例

pycuda.gpuarray.to_gpu(ary, allocator=None)

返回A GPUArray 那是 numpy.ndarray 实例 ary .

GPUArray 为了…的意义 分配器 .

pycuda.gpuarray.to_gpu_async(ary, allocator=None, stream=None)

返回A GPUArray 那是 numpy.ndarray 实例 ary . 复制是异步完成的,可以选择顺序为 流动 .

GPUArray 为了…的意义 分配器 .

pycuda.gpuarray.empty(shape, dtype, *, allocator=None, order='C')

的同义词 GPUArray 建造师。

pycuda.gpuarray.zeros(shape, dtype, *, allocator=None, order='C')

等同于 empty() 但是 GPUArray 在返回之前初始化为零。

pycuda.gpuarray.empty_like(other_ary, dtype=None, order='K')

创建新的、未初始化的 GPUArray 具有与 other_ary . 这个 D型秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.zeros_like(other_ary, dtype=None, order='K')

创建一个新的、初始化为零的 GPUArray 具有与 other_ary . 这个 D型秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.ones_like(other_ary, dtype=None, order='K')

创建一个新的,已初始化的 GPUArray 具有与 other_ary . 这个 D型秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。

pycuda.gpuarray.arange(start, stop, step, dtype=None, stream=None)

创建一个 GPUArray 填充数字间隔 step 分开,从 start 结束于 stop .

对于浮点参数,结果的长度为 ceil((stop - start)/step) . 此规则可能导致结果的最后一个元素大于 stop .

D型 ,如果未指定,则被视为 开始stopstep .

pycuda.gpuarray.take(a, indices, stream=None)

返回 GPUArray [a[indices[0]], ..., a[indices[n]]] . 就目前而言, a 必须是可以绑定到纹理的类型。

条件句

pycuda.gpuarray.if_positive(criterion, then_, else_, out=None, stream=None)

返回类似于 then_ ,对于索引处的元素 i 包含 [then_[i]] 如果 [criterion[i]>0] ,否则 [else_[i]] . (在0.94中添加)

pycuda.gpuarray.maximum(a, b, out=None, stream=None)

返回元素的最大值 ab . (在0.94中添加)

pycuda.gpuarray.minimum(a, b, out=None, stream=None)

返回元素的最小值 ab . (在0.94中添加)

约简

pycuda.gpuarray.sum(a, dtype=None, stream=None)
pycuda.gpuarray.subset_sum(subset, a, dtype=None, stream=None)

2013.1 新版功能.

pycuda.gpuarray.dot(a, b, dtype=None, stream=None)
pycuda.gpuarray.subset_dot(subset, a, b, dtype=None, stream=None)
pycuda.gpuarray.max(a, stream=None)
pycuda.gpuarray.min(a, stream=None)
pycuda.gpuarray.subset_max(subset, a, stream=None)
pycuda.gpuarray.subset_min(subset, a, stream=None)

上的元素级函数 GPUArray 实例

这个 pycuda.cumath 模块包含包含 math .

舍入和绝对值

pycuda.cumath.fabs(array, *, out=None, stream=None)
pycuda.cumath.ceil(array, *, out=None, stream=None)
pycuda.cumath.floor(array, *, out=None, stream=None)

指数、对数和根

pycuda.cumath.exp(array, *, out=None, stream=None)
pycuda.cumath.log(array, *, out=None, stream=None)
pycuda.cumath.log10(array, *, out=None, stream=None)
pycuda.cumath.sqrt(array, *, out=None, stream=None)

三角函数

pycuda.cumath.sin(array, *, out=None, stream=None)
pycuda.cumath.cos(array, *, out=None, stream=None)
pycuda.cumath.tan(array, *, out=None, stream=None)
pycuda.cumath.asin(array, *, out=None, stream=None)
pycuda.cumath.acos(array, *, out=None, stream=None)
pycuda.cumath.atan(array, *, out=None, stream=None)

双曲函数

pycuda.cumath.sinh(array, *, out=None, stream=None)
pycuda.cumath.cosh(array, *, out=None, stream=None)
pycuda.cumath.tanh(array, *, out=None, stream=None)

浮点分解与汇编

pycuda.cumath.fmod(arg, mod, stream=None)

返回除法的浮点余数 arg/mod ,对于中的每个元素 argmod .

pycuda.cumath.frexp(arg, stream=None)

返回元组 (significands, exponents) 这样的话 arg == significand * 2**exponent .

pycuda.cumath.ldexp(significand, exponent, stream=None)

返回一个新的浮点值数组,该数组由 significandexponent ,配对为 result = significand * 2**exponent .

pycuda.cumath.modf(arg, stream=None)

返回元组 (fracpart, intpart) 包含 arg .

生成随机数数组

pycuda.curandom.rand(shape, dtype=numpy.float32, stream=None)

返回一个数组 shape 填充随机值 dtype 在[0,1]范围内。

注解

这个函数的用例是“我需要一些随机数。它使用了一个非常糟糕的基于md5的生成器,甚至不尝试缓存生成的代码。

如果您对非玩具随机数生成器感兴趣,请使用下面基于curand的功能。

警告

以下类使用在GPU上运行的随机数生成器。每个线程都使用自己的生成器。创建这些生成器比随后生成的随机数需要更多的资源。在实验之后,特斯拉设备上的最大活动发电机数量(计算能力为1.x)看起来是256个。费米装置允许创建1024个发电机没有任何问题。如果创建类pseudorandomNumberGenerator或quasirandomNumberGenerator的对象时出现问题,请减少创建的生成器的数量(从而减少活动线程的数量)。

伪随机数列满足真正随机数列的大多数统计特性,但由确定性算法生成。利用均匀填充n维空间的确定性算法生成n维点的拟irandom序列。

类星体数字的生成成本更高。

pycuda.curandom.get_curand_version()

获取PyCUDA编译的Curand版本。返回3元组整数作为 (主要、次要、修订) .

pycuda.curandom.seed_getter_uniform(N)

返回一 GPUArray 充满一个随机的 int32 重复的 N 可以用作XOWOW发生器的种子的时间。

pycuda.curandom.seed_getter_unique(N)

返回一 GPUArray 充满 N 随机的 int32 可以作为XOWOW发生器的种子使用。

class pycuda.curandom.XORWOWRandomNumberGenerator(seed_getter=None, offset=0)
参数
  • seed_getter -- 一个给定整数计数的函数,它将产生一个 int32 GPUArray 种子的

  • offset -- 给定种子,开始索引到xorwow序列。

提供伪随机数。生成至少包含周期的序列 \(2^190\) .

CUDA 3.2及以上。

2011.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed pseudorandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed pseudorandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

2012.2 新版功能.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

CUDA 4.0及以上。

2012.2 新版功能.

fill_poisson(data, lambda_value=None, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

call_skip_ahead_sequence(i, stream=None)

强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果,但要快得多。

call_skip_ahead_sequence_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少子序列。

class pycuda.curandom.MRG32k3aRandomNumberGenerator(seed_getter=None, offset=0)
参数
  • seed_getter -- 一个给定整数计数的函数,它将产生一个 int32 GPUArray 种子的

  • offset -- 给定种子,开始索引到xorwow序列。

提供伪随机数。生成至少包含周期的序列 \(2^190\) .

CUDA 4.1及以上。

2013.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed pseudorandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed pseudorandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

fill_poisson(data, lambda_value, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

call_skip_ahead_sequence(i, stream=None)

强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果,但要快得多。

call_skip_ahead_sequence_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少子序列。

pycuda.curandom.generate_direction_vectors(count, direction=direction_vector_set.VECTOR_32)

返回一 GPUArray count 填充用于初始化sobol生成器的方向向量。

pycuda.curandom.generate_scramble_constants32(count)

返回A GPUArray 充满 count' 32-bit unsigned integer numbers used to initialize :class: 加扰双簧管32和数字发电机`

pycuda.curandom.generate_scramble_constants64(count)

返回A GPUArray 充满 count' 64-bit unsigned integer numbers used to initialize :class: 随机数发生器`

class pycuda.curandom.Sobol32RandomNumberGenerator(dir_vector=None, offset=0)
参数
  • dir_vector -- 一 GPUArray 共32个元素 int32 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量

  • offset -- 开始索引到sobol32序列,给定方向向量。

提供类irandom数。生成周期为的序列 \(2^32\) .

CUDA 3.2及以上。

2011.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

2012.2 新版功能.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

CUDA 4.0及以上。

2012.2 新版功能.

fill_poisson(data, lambda_value, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

class pycuda.curandom.ScrambledSobol32RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)
参数
  • dir_vector -- 一 GPUArray 共32个元素 uint32 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量

  • scramble_vector -- 一 GPUArray 属于 uint32 用于初始化Quasirandom生成器的元素;每个初始化生成器必须包含一个数字

  • offset -- 开始索引到sobol32序列,给定方向向量。

提供类irandom数。生成周期为的序列 \(2^32\) .

CUDA 4.0及以上。

2011.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

2012.2 新版功能.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

CUDA 4.0及以上。

2012.2 新版功能.

fill_poisson(data, lambda_value, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

class pycuda.curandom.Sobol64RandomNumberGenerator(dir_vector=None, offset=0)
参数
  • dir_vector -- 一 GPUArray 共64个元素 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量

  • offset -- 给定方向向量,开始索引到sobol64序列。

提供类irandom数。生成周期为的序列 \(2^64\) .

CUDA 4.0及以上。

2011.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

2012.2 新版功能.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

CUDA 4.0及以上。

2012.2 新版功能.

fill_poisson(data, lambda_value, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

class pycuda.curandom.ScrambledSobol64RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)
参数
  • dir_vector -- 一 GPUArray 共64个元素 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量

  • scramble_vector -- 一 GPUArray 属于 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量

  • offset -- 在给定方向向量的情况下,开始索引到加扰双簧管64序列。

提供类irandom数。生成周期为的序列 \(2^64\) .

CUDA 4.0及以上。

2011.1 新版功能.

fill_uniform(data, stream=None)

Fills in GPUArray data with uniformly distributed quasirandom values.

gen_uniform(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。

fill_normal(data, stream=None)

Fills in GPUArray data with normally distributed quasirandom values.

gen_normal(shape, dtype, stream=None)

创建对象 GPUArray 给予 形状D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。

fill_log_normal(data, mean, stddev, stream=None)

Fills in GPUArray data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.

CUDA 4.0及以上。

2012.2 新版功能.

gen_log_normal(shape, dtype, mean, stddev, stream=None)

创建对象 GPUArray 给予 形状D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。

CUDA 4.0及以上。

2012.2 新版功能.

fill_poisson(data, lambda_value, stream=None)

Fills in GPUArray data with Poisson distributed pseudorandom values.

如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。

如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。

CUDA 5.0及以上。

2013.1 新版功能.

gen_poisson(shape, dtype, lambda_value, stream=None)

创建对象 GPUArray 给予 形状D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。

CUDA 5.0及以上。

2013.1 新版功能.

call_skip_ahead(i, stream=None)

强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。

call_skip_ahead_array(i, stream=None)

接受整数值数组i,告诉每个生成器要跳过多少个值。

单程自定义表达式求值

计算上涉及的表达式 GPUArray 实例可能有点低效,因为为每个中间结果创建了一个新的临时。模块中的功能 pycuda.elementwise 包含有助于生成内核的工具,这些内核在一次传递中对一个或多个操作数计算多级表达式。

class pycuda.elementwise.ElementwiseKernel(arguments, operation, name='kernel', keep=False, options=[], preamble='')

生成一个核,该核接受多个标量或向量 参数 并执行标量 操作 在其参数的每个条目上,如果该参数是向量。

参数 指定为格式化为C参数列表的字符串。 操作 指定为C赋值语句,不带分号。向量在 操作 应该由变量索引 i .

name 指定编译内核的名称, keep选项 未经修改传递给 pycuda.compiler.SourceModule .

序言 指定在ElementWise内核规范之前包含的一些源代码。您可以使用它来包含其他文件和/或定义 操作 .

__call__(*args, range=None, slice=None)

调用生成的标量内核。参数可以是标量或 GPUArray 实例。

如果 范围 是的,一定是 slice 对象并指定索引的范围。 i 为此 操作 执行。

如果 是的,一定是 slice 对象并指定索引的范围。 i 为此 操作 执行,截断到容器。也, 可能包含相对于数组结尾的负索引。

如果 流动 是的,一定是 pycuda.driver.Stream 对象,执行将在其中序列化。

下面是一个用法示例:

import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
import pycuda.autoinit
import numpy
from pycuda.curandom import rand as curand

a_gpu = curand((50,))
b_gpu = curand((50,))

from pycuda.elementwise import ElementwiseKernel
lin_comb = ElementwiseKernel(
        "float a, float *x, float b, float *y, float *z",
        "z[i] = a*x[i] + b*y[i]",
        "linear_combination")

c_gpu = gpuarray.empty_like(a_gpu)
lin_comb(5, a_gpu, 6, b_gpu, c_gpu)

import numpy.linalg as la
assert la.norm((c_gpu - (5*a_gpu+6*b_gpu)).get()) < 1e-5

(你可以找到这个例子 examples/demo_elementwise.py 在Pycuda分布中。)

自定义缩减

class pycuda.reduction.ReductionKernel(dtype_out, neutral, reduce_expr, map_expr=None, arguments=None, name='reduce_kernel', keep=False, options=[], preamble='', allocator=None)

生成一个核,该核接受多个标量或向量 参数 (至少一个向量参数),执行 map_expr 在向量参数的每个条目上,然后 reduce_expr 关于结果。 中立的 作为初始值。 序言 提供了在实际的缩减内核代码之前添加预处理器指令和其他代码(如助手函数)的可能性。

向量在 map_expr 应该由变量索引 i . reduce_expr 使用形式值“a”和“b”指示二进制缩减操作的两个操作数。如果未指定 map_expr ,“在 [i] “——因此只存在一个输入参数——是自动假定的。 reduce_expr 必须是关联的。

dtype_out 指定 numpy.dtype 其中执行缩减并返回结果。 中立的 指定为浮点或格式为字符串的整数。 reduce_exprmap_expr 指定为字符串格式的操作和 参数 指定为格式化为C参数列表的字符串。 name 指定编译内核的名称, keep选项 未经修改传递给 pycuda.compiler.SourceModule . 序言 指定为代码字符串。

__call__(*args, stream=None, out=None)

调用生成的缩减内核。参数可以是标量,也可以是 GPUArray 实例。将对第一个向量参数的每个条目进行缩减。

如果 流动 是的,一定是 pycuda.driver.Stream 对象,执行将在其中序列化。

out 生成的单个条目 GPUArray 可以指定。因为支持偏移,所以可以在任何地方存储结果(例如out=a [3] )

下面是一个用法示例:

a = gpuarray.arange(400, dtype=numpy.float32)
b = gpuarray.arange(400, dtype=numpy.float32)

krnl = ReductionKernel(numpy.float32, neutral="0",
        reduce_expr="a+b", map_expr="x[i]*y[i]",
        arguments="float *x, float *y")

my_dot_prod = krnl(a, b).get()

或通过指定输出:

from pycuda.curandom import rand as curand
a = curand((10, 200), dtype=np.float32)
red = ReductionKernel(np.float32, neutral=0,
                           reduce_expr="a+b",
                           arguments="float *in")
a_sum = gpuarray.empty(10, dtype=np.float32)
for i in range(10):
    red(a[i], out=a_sum[i])
assert(np.allclose(a_sum.get(), a.get().sum(axis=1)))

并行扫描/前缀和

class pycuda.scan.ExclusiveScanKernel(dtype, scan_expr, neutral, name_prefix='scan', options=[], preamble='')

生成一个可以计算 prefix sum 使用任何关联操作 scan_expr . scan_expr 使用形式值“a”和“b”指示关联二进制运算的两个操作数。 中立的 是中性元素 scan_expr 服从 scan_expr(a, neutral) == a .

D型 指定要操作的数组的类型。 name_prefix 用于内核名称,以确保配置文件和日志中的可识别性。 选项 是生成时要使用的编译器选项的列表。 序言 指定在实际内核之前插入的代码字符串。

__call__(self, input_ary, output_ary=None, allocator=None, queue=None)
class pycuda.scan.InclusiveScanKernel(dtype, scan_expr, neutral=None, name_prefix='scan', options=[], preamble='', devices=None)

作品像 ExclusiveScanKernel . 与独家案件不同, 中立的 不是必需的。

下面是一个用法示例:

knl = InclusiveScanKernel(np.int32, "a+b")

n = 2**20-2**18+5
host_data = np.random.randint(0, 10, n).astype(np.int32)
dev_data = gpuarray.to_gpu(queue, host_data)

knl(dev_data)
assert (dev_data.get() == np.cumsum(host_data, axis=0)).all()

缩小和扫描中的自定义数据类型

如果要在扫描和缩减中使用自己的(struct/union/whatever)数据类型,请在 序言 使用此函数让pycuda知道它们:

pycuda.tools.register_dtype(dtype, name)

D型 是一个 numpy.dtype() .

gpgpu算法

博格丹奥潘丘克 reikna 提供了多种基于gpu的算法(fft、rng、矩阵乘法),可用于 pycuda.gpuarray.GPUArray 物体。