设备接口#

版本查询#

pycuda.VERSION#

将PYCUDA的数值版本作为整数的可变长度元组。启用简单的版本检查，例如 VERSION >= (0, 93) .

在Pycuda中添加0.93。

pycuda.VERSION_STATUS#: 文本字符串，如 "rc4" 或 "beta" 限定发布的状态。

在 0.93 版本加入.

pycuda.VERSION_TEXT#: 完整的发布名称（例如 "0.93rc4" ）以字符串形式。

在 0.93 版本加入.

错误报告#

exception pycuda.driver.Error#: 所有pycuda错误的基类。

exception pycuda.driver.CompileError#

投掷时 pycuda.compiler.SourceModule 编译失败。

msg#: 在 0.94 版本加入.

stdout#: 在 0.94 版本加入.

stderr#: 在 0.94 版本加入.

command_line#: 在 0.94 版本加入.

exception pycuda.driver.MemoryError#: 投掷时 mem_alloc() 或相关功能失效。

exception pycuda.driver.LogicError#

当PyCuda遇到一个程序员可能犯了错误的情况时抛出。 LogicErrors 不要依赖于运行时环境定义的外部环境。

示例：在初始化之前使用CUDA。

exception pycuda.driver.LaunchError#: 内核调用失败时引发。（注意，这通常会在实际内核调用之后的下一次调用中报告。）

exception pycuda.driver.RuntimeError#

当遇到不可预见的运行时故障时抛出，该故障不太可能是由于程序员错误造成的。

示例：找不到文件。

常量#

class pycuda.driver.ctx_flags#

旗帜 Device.make_context() . 仅限CUDA 2.0及以上版本。

SCHED_AUTO#: 如果有比处理器更多的上下文，则屈服，否则在等待CUDA调用完成时旋转。

SCHED_SPIN#: 在等待CUDA呼叫完成时旋转。

SCHED_YIELD#: 在等待CUDA调用完成时屈服于其他线程。

SCHED_MASK#: 此位字段中有效调度标志的掩码。

SCHED_BLOCKING_SYNC#: 使用阻塞同步。CUDA 2.2及更新版本。

MAP_HOST#: 支持映射的固定分配。CUDA 2.2及更新版本。

LMEM_RESIZE_TO_MAX#: 启动后保留本地内存分配。CUDA 3.2及更新版本。传闻减少费米发射开销？

在 2011.1 版本加入.

FLAGS_MASK#: 此位字段中有效标志的掩码。

class pycuda.driver.event_flags#

旗帜 Event . CUDA 2.2及更新版本。

DEFAULT#

BLOCKING_SYNC#

DISABLE_TIMING#: CUDA 3.2及更新版本。

在 0.94 版本加入.

INTERPROCESS#: CUDA 4.1及更新版本。

在 2011.2 版本加入.

class pycuda.driver.device_attribute#

MAX_THREADS_PER_BLOCK#

MAX_BLOCK_DIM_X#

MAX_BLOCK_DIM_Y#

MAX_BLOCK_DIM_Z#

MAX_GRID_DIM_X#

MAX_GRID_DIM_Y#

MAX_GRID_DIM_Z#

TOTAL_CONSTANT_MEMORY#

WARP_SIZE#

MAX_PITCH#

CLOCK_RATE#

TEXTURE_ALIGNMENT#

GPU_OVERLAP#

MULTIPROCESSOR_COUNT#: 仅限CUDA 2.0及以上版本。

SHARED_MEMORY_PER_BLOCK#: 自CUDA 2.0起已弃用。更换见下文。

MAX_SHARED_MEMORY_PER_BLOCK#: 仅限CUDA 2.0及以上版本。

REGISTERS_PER_BLOCK#: 自CUDA 2.0起已弃用。更换见下文。

MAX_REGISTERS_PER_BLOCK#: CUDA 2.0及以上。

KERNEL_EXEC_TIMEOUT#: CUDA 2.2及以上。

INTEGRATED#: CUDA 2.2及以上。

CAN_MAP_HOST_MEMORY#: CUDA 2.2及以上。

COMPUTE_MODE#: CUDA 2.2及以上。见 compute_mode .

MAXIMUM_TEXTURE1D_WIDTH#
MAXIMUM_TEXTURE2D_WIDTH#
MAXIMUM_TEXTURE2D_HEIGHT#
MAXIMUM_TEXTURE3D_WIDTH#
MAXIMUM_TEXTURE3D_HEIGHT#
MAXIMUM_TEXTURE3D_DEPTH#
MAXIMUM_TEXTURE2D_ARRAY_WIDTH#
MAXIMUM_TEXTURE2D_ARRAY_HEIGHT#
MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES#: CUDA 3.0及以上。

在 0.94 版本加入.

MAXIMUM_TEXTURE2D_LAYERED_WIDTH#
MAXIMUM_TEXTURE2D_LAYERED_HEIGHT#
MAXIMUM_TEXTURE2D_LAYERED_LAYERS#
MAXIMUM_TEXTURE1D_LAYERED_WIDTH#
MAXIMUM_TEXTURE1D_LAYERED_LAYERS#: CUDA 4.0及以上。

在 2011.1 版本加入.

SURFACE_ALIGNMENT#: CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

CONCURRENT_KERNELS#: CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

ECC_ENABLED#: CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

PCI_BUS_ID#: CUDA 3.2及以上。

在 0.94 版本加入.

PCI_DEVICE_ID#: CUDA 3.2及以上。

在 0.94 版本加入.

TCC_DRIVER#: CUDA 3.2及以上。

在 0.94 版本加入.

MEMORY_CLOCK_RATE#
GLOBAL_MEMORY_BUS_WIDTH#
L2_CACHE_SIZE#
MAX_THREADS_PER_MULTIPROCESSOR#
ASYNC_ENGINE_COUNT#
UNIFIED_ADDRESSING#: CUDA 4.0及以上。

在 2011.1 版本加入.

MAXIMUM_TEXTURE2D_GATHER_WIDTH#
MAXIMUM_TEXTURE2D_GATHER_HEIGHT#
MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE#
MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE#
MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE#
PCI_DOMAIN_ID#
TEXTURE_PITCH_ALIGNMENT#
MAXIMUM_TEXTURECUBEMAP_WIDTH#
MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH#
MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS#
MAXIMUM_SURFACE1D_WIDTH#
MAXIMUM_SURFACE2D_WIDTH#
MAXIMUM_SURFACE2D_HEIGHT#
MAXIMUM_SURFACE3D_WIDTH#
MAXIMUM_SURFACE3D_HEIGHT#
MAXIMUM_SURFACE3D_DEPTH#
MAXIMUM_SURFACE1D_LAYERED_WIDTH#
MAXIMUM_SURFACE1D_LAYERED_LAYERS#
MAXIMUM_SURFACE2D_LAYERED_WIDTH#
MAXIMUM_SURFACE2D_LAYERED_HEIGHT#
MAXIMUM_SURFACE2D_LAYERED_LAYERS#
MAXIMUM_SURFACECUBEMAP_WIDTH#
MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH#
MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS#
MAXIMUM_TEXTURE1D_LINEAR_WIDTH#
MAXIMUM_TEXTURE2D_LINEAR_WIDTH#
MAXIMUM_TEXTURE2D_LINEAR_HEIGHT#
MAXIMUM_TEXTURE2D_LINEAR_PITCH#: CUDA 4.1及以上。

在 2011.2 版本加入.

MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH#
MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT#
COMPUTE_CAPABILITY_MAJOR#
COMPUTE_CAPABILITY_MINOR#
MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH#: CUDA 5.0及以上。

在 2014.1 版本加入.

STREAM_PRIORITIES_SUPPORTED#: CUDA 5.5及以上。

在 2014.1 版本加入.

GLOBAL_L1_CACHE_SUPPORTED#
LOCAL_L1_CACHE_SUPPORTED#
MAX_SHARED_MEMORY_PER_MULTIPROCESSOR#
MAX_REGISTERS_PER_MULTIPROCESSOR#
MANAGED_MEMORY#
MULTI_GPU_BOARD#
MULTI_GPU_BOARD_GROUP_ID#: CUDA 6.0及以上。

在 2014.1 版本加入.

HOST_NATIVE_ATOMIC_SUPPORTED#
SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO#
PAGEABLE_MEMORY_ACCESS#
CONCURRENT_MANAGED_ACCESS#
COMPUTE_PREEMPTION_SUPPORTED#
CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM#: Cuda 8.0及以上版本。

MAX_SHARED_MEMORY_PER_BLOCK_OPTIN#: Cuda 9.0及以上版本。

PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES#
DIRECT_MANAGED_MEM_ACCESS_FROM_HOST#: Cuda 9.2及以上版本。

HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED#
HANDLE_TYPE_WIN32_HANDLE_SUPPORTED#
HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED#: Cuda 10.2及以上版本。

MAX_PERSISTING_L2_CACHE_SIZE#
MAX_BLOCKS_PER_MULTIPROCESSOR#
GENERIC_COMPRESSION_SUPPORTED#
RESERVED_SHARED_MEMORY_PER_BLOCK#: Cuda 11.0及以上版本。

READ_ONLY_HOST_REGISTER_SUPPORTED#
MEMORY_POOLS_SUPPORTED#: Cuda 11.2及以上版本。

class pycuda.driver.pointer_attribute#

CONTEXT#
MEMORY_TYPE#
DEVICE_POINTER#
HOST_POINTER#

CUDA 4.0及以上。

在 2011.1 版本加入.

class pycuda.driver.profiler_output_mode#

KEY_VALUE_PAIR#
CSV#

CUDA 4.0及以上。

在 2011.1 版本加入.

class pycuda.driver.function_attribute#

旗帜 Function.get_attribute() . CUDA 2.2及更新版本。

MAX_THREADS_PER_BLOCK#

SHARED_SIZE_BYTES#

CONST_SIZE_BYTES#

LOCAL_SIZE_BYTES#

NUM_REGS#

PTX_VERSION#: CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

BINARY_VERSION#: CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

CACHE_MODE_CA#: 在 2022.1 版本加入.

MAX_DYNAMIC_SHARED_SIZE_BYTES#: 在 2022.1 版本加入.

PREFERRED_SHARED_MEMORY_CARVEOUT#: 在 2022.1 版本加入.

MAX#

class pycuda.driver.func_cache#

见 Function.set_cache_config() . CUDA 3.0（测试后）及以上版本。

在 0.94 版本加入.

PREFER_NONE#

PREFER_SHARED#

PREFER_L1#

PREFER_EQUAL#: CUDA 4.1及以上。

在 2011.2 版本加入.

class pycuda.driver.shared_config#

见 Function.set_shared_config() . CUDA 4.2及以上。

DEFAULT_BANK_SIZE#

FOUR_BYTE_BANK_SIZE#

EIGHT_BYTE_BANK_SIZE#

class pycuda.driver.array_format#

UNSIGNED_INT8#

UNSIGNED_INT16#

UNSIGNED_INT32#

SIGNED_INT8#

SIGNED_INT16#

SIGNED_INT32#

HALF#

FLOAT#

class pycuda.driver.array3d_flags#

2DARRAY#: CUDA 3.0及以上。不推荐--使用 LAYERED .

在 0.94 版本加入.

LAYERED#: CUDA 4.0及以上。

在 2011.1 版本加入.

SURFACE_LDST#: CUDA 3.1及以上。

在 0.94 版本加入.

CUBEMAP TEXTURE_GATHER: CUDA 4.1及以上。

在 2011.2 版本加入.

class pycuda.driver.address_mode#

WRAP#

CLAMP#

MIRROR#

BORDER#: CUDA 3.2及以上。

在 0.94 版本加入.

class pycuda.driver.filter_mode#

POINT#

LINEAR#

class pycuda.driver.memory_type#

HOST#

DEVICE#

ARRAY#

class pycuda.driver.compute_mode#

CUDA 2.2及更新版本。

DEFAULT#

PROHIBITED#

EXCLUSIVE_PROCESS#: CUDA 4.0及以上。

在 2011.1 版本加入.

class pycuda.driver.jit_option#

CUDA 2.1及更新版本。

MAX_REGISTERS#

THREADS_PER_BLOCK#

WALL_TIME#

INFO_LOG_BUFFER#

INFO_LOG_BUFFER_SIZE_BYTES#

ERROR_LOG_BUFFER#

ERROR_LOG_BUFFER_SIZE_BYTES#

OPTIMIZATION_LEVEL#

TARGET_FROM_CUCONTEXT#

TARGET#

FALLBACK_STRATEGY#

class pycuda.driver.jit_target#

CUDA 2.1及更新版本。

COMPUTE_10#

COMPUTE_11#

COMPUTE_12#

COMPUTE_13#

COMPUTE_20#: CUDA 3.0及以上。

在 0.94 版本加入.

COMPUTE_21#: CUDA 3.2及以上。

在 0.94 版本加入.

class pycuda.driver.jit_fallback#

CUDA 2.1及更新版本。

PREFER_PTX#

PREFER_BINARY#

class pycuda.driver.host_alloc_flags#

用于分配的标志分页锁定主机内存 .

PORTABLE#

DEVICEMAP#

WRITECOMBINED#

class pycuda.driver.mem_attach_flags#

用于分配的标志托管内存 .

…版本附加：：2014.1

GLOBAL#

HOST#

SINGLE#

class pycuda.driver.mem_host_register_flags#

PORTABLE#

DEVICEMAP#

CUDA 4.0及更新版本。

在 2011.1 版本加入.

class pycuda.driver.limit#

的限制值 Context.get_limit() 和 Context.set_limit() .

CUDA 3.1及更新版本。

在 0.94 版本加入.

STACK_SIZE#

PRINTF_FIFO_SIZE#

MALLOC_HEAP_SIZE#: CUDA 3.2及以上。

class pycuda.driver.ipc_mem_flags#

LAZY_ENABLE_PEER_ACCESS#

设备和上下文#

pycuda.driver.get_version()#: 获取PyCuda编译的CUDA版本。返回3元组整数作为 （主要、次要、修订） .

pycuda.driver.get_driver_version()#: 获取运行pycuda的cuda驱动程序的版本。返回整数版本号。

pycuda.driver.init(flags=0)#

初始化CUDA。

警告

此函数必须在此模块中的任何其他函数之前调用。

也见 pycuda.autoinit .

class pycuda.driver.Device(number)#

class pycuda.driver.Device(pci_bus_id)

把手数这是cuda设备。也见 pycuda.autoinit .

在 2011.2 版本发生变更: 这个 pci_bus_id 构造函数的版本是CUDA4.1中的新版本。

static count()#: 返回找到的CUDA设备数。

name()#

pci_bus_id()#: CUDA 4.1及更新版本。

在 2011.2 版本加入.

compute_capability()#: 返回一个2元组，指示此设备的计算功能版本。

total_memory()#: 返回设备上的内存总量（字节）。

get_attribute(attr)#

返回属性的（数字）值 attr ，可能是 device_attribute 价值观。

所有 device_attribute 值也可以直接读取为 Device 对象本身，例如 dev.clock_rate .

get_attributes()#: 返回 dict ，键来自 device_attribute .

make_context(flags=ctx_flags.SCHED_AUTO)#

创建一个 Context 在这个设备上，从 ctx_flags 价值观。

同时将新创建的上下文设置为当前上下文。

retain_primary_context()#

返回 Context 通过保留设备的主上下文（CUDA运行时API使用的主上下文）获取。不像 Context.make_context() ，新创建的上下文未成为当前上下文。

CUDA 7.0及更新版本。

在 2020.1 版本加入.

can_access_peer(dev)#: CUDA 4.0及更新版本。

在 2011.1 版本加入.

__hash__()#

__eq__()#

__ne__()#

class pycuda.driver.Context#

相当于计算设备上的unix进程。使用创建此类的实例 Device.make_context() . 也见 pycuda.autoinit .

detach()#: 减少此上下文上的引用计数。如果引用计数为零，则删除上下文。

push()#: 制作 self 活动上下文，将其推到上下文堆栈的顶部。仅限CUDA 2.0及以上版本。

static pop()#: 从上下文堆栈的顶部移除任何上下文，将其停用。仅限CUDA 2.0及以上版本。

static get_device()#: 返回当前上下文正在处理的设备。

static synchronize()#: 等待当前上下文中的所有活动停止，然后返回。

static set_limit(limit, value)#

见 limit 对于可能的值限制 .

CUDA 3.1及以上。

在 0.94 版本加入.

static get_limit(limit)#

见 limit 对于可能的值限制 .

CUDA 3.1及以上。

在 0.94 版本加入.

static set_cache_config(cc)#

见 func_cache 对于可能的值 cc .

CUDA 3.2及以上。

在 0.94 版本加入.

static get_cache_config()#

返回值 func_cache .

CUDA 3.2及以上。

在 0.94 版本加入.

static set_shared_config(sc)#

见 shared_config 对于可能的值 sc .

CUDA 4.2及以上。

在 2013.1 版本加入.

static get_shared_config()#

返回值 shared_config .

CUDA 4.2及以上。

在 2013.1 版本加入.

get_api_version()#

返回整数API版本号。

CUDA 3.2及以上。

在 0.94 版本加入.

enable_peer_access(peer, flags=0)#: CUDA 4.0及以上。

在 2011.1 版本加入.

disable_peer_access(peer, flags=0)#: CUDA 4.0及以上。

在 2011.1 版本加入.

并发和流#

class pycuda.driver.Stream(flags=0)#

将按顺序执行的操作队列的句柄。

synchronize()#: 等待此流上的所有活动停止，然后返回。

is_done()#: 返回 True 如果所有排队操作都已完成。

wait_for_event(evt)#

排队等待给定的 Event 实例。

CUDA 3.2及以上。

在 2011.1 版本加入.

class pycuda.driver.Event(flags=0)#

事件是 Stream 这允许在两个事件之间花费时间——例如执行内核所需的时间。当 Stream 已完成在 record() 打电话。

见 event_flags 对于旗帜参数。

record(stream=None)#: Insert a recording point for self into the Stream stream. Return self.

synchronize()#: 等待设备执行流到达此事件。返回 self .

query()#: 返回 True 如果设备执行流已到达此事件。

time_since(event)#: 返回之间经过的时间（毫秒） self 和事件 . 使用此方法作为 end.time_since(start) . 请注意，如果尚未达到任一事件，则此方法将失败，并出现“无效值”错误。使用 synchronize() 以确保已到达事件。

time_till(event)#: 返回之间经过的时间（毫秒）事件和 self . 使用此方法作为 start.time_till(end) . 请注意，如果尚未达到任一事件，则此方法将失败，并出现“无效值”错误。使用 synchronize() 以确保已到达事件。

ipc_handle()#: 返回A bytes 对象，表示此事件的IPC句柄。需要Python2.6和CUDA4.1。

static from_ipc_handle(handle)#: 需要Python2.6和CUDA4.1。

Memory#

全局设备内存#

pycuda.driver.mem_get_info()#: 返回元组 （免费，总计） 指示当前上下文中的可用内存和总内存（字节）。

pycuda.driver.mem_alloc(bytes)#: 返回A DeviceAllocation 对象，表示设备内存的线性部分。

pycuda.driver.to_device(buffer)#: 为分配足够的设备内存 缓冲区 ，它遵循python buffer 接口。复制的内容 缓冲区 在设备上。返回A DeviceAllocation 对象，表示新分配的内存。

pycuda.driver.from_device(devptr, shape, dtype, order='C')#: 做一个新的 numpy.ndarray 数据来源于 德普特 在GPU上，用形状， D型和秩序 .

pycuda.driver.from_device_like(devptr, other_ary)#: 做一个新的 numpy.ndarray 数据来源于 德普特 在gpu上，将它们解释为具有与 other_ary .

pycuda.driver.mem_alloc_pitch(width, height, access_size)#

至少分配一段线性设备内存宽度字节宽和高度使用大小的数据类型访问的高行 access_size 以联合的方式。

返回元组 (dev_alloc, actual_pitch) 给予一个 DeviceAllocation 以及每行的实际宽度（字节）。

class pycuda.driver.DeviceAllocation#

表示线性设备存储器分配的对象。删除此对象后，将释放其关联的设备内存。

这种类型的对象可以被转换为 int 为了得到一个线性指数 Context 的记忆。

free()#: 现在释放保留的设备内存，而不是在无法访问此对象时释放。任何对对象的进一步使用都是一个错误，将导致未定义的行为。

as_buffer(size, offset=0)#: 返回由 self 作为python缓冲区对象， size 而且，有选择地，抵消 .

在 2014.1 版本加入.

pycuda.driver.mem_get_ipc_handle(devptr)#

返回不透明的 bytes 对象，表示设备指针的IPC句柄。 德普特 .

在 2011.2 版本加入.

需要CUDA4.1和Python2.6。

class pycuda.driver.IPCMemoryHandle(ipc_handle, flags=ipc_mem_flags.LAZY_ENABLE_PEER_ACCESS)#

在 2011.2 版本加入.

需要CUDA4.1和Python2.6。

这种类型的对象可以以与 DeviceAllocation .

close()#

class pycuda.driver.PointerHolderBase#

一个基类，有助于转换到pycuda中的指针。这允许用户构造自定义指针类型，这些类型可能是由pycuda proper之外的工具分配的，但仍然需要成为对象来促进raii。用户需要提供一种方法来简化指针转换：

get_pointer()#: 返回由 self .

as_buffer(size, offset=0)#: 返回由 self 作为python缓冲区对象， size 而且，有选择地，抵消 .

在 2014.1 版本加入.

备注

如果您的子类提供其自己的 __init__() ，则它必须调用基类 __init__() 。如果不这样做，将导致 Boost.Python.ArgumentError 在使用时被抬高。

分页锁定主机内存#

页面锁定分配#

pycuda.driver.pagelocked_empty(shape, dtype, order='C', mem_flags=0)#

分配页面锁定 numpy.ndarray 属于形状， D型和秩序 .

mem_flags 可能是 host_alloc_flags . 在cuda 2.2和更新版本上可能只有非零。

有关其他参数的含义，请参阅 numpy 文档。

pycuda.driver.pagelocked_zeros(shape, dtype, order='C', mem_flags=0)#: 喜欢 pagelocked_empty() ，但初始化为零。

pycuda.driver.pagelocked_empty_like(array, mem_flags=0)#

pycuda.driver.pagelocked_zeros_like(array, mem_flags=0)#

这个 numpy.ndarray 这些函数返回的实例具有一个属性 base 引用类型为

class pycuda.driver.PagelockedHostAllocation#

继承自 HostPointer .

表示分页锁定主机内存分配的对象。删除此对象后，将释放其关联的设备内存。

free()#: 现在释放保留的内存，而不是当这个对象变得不可访问时。对象（或其关联对象）的任何进一步使用 numpy 数组）是一个错误，将导致未定义的行为。

get_flags()#

返回值的位字段 host_alloc_flags .

仅适用于CUDA 3.2及更新版本。

在 0.94 版本加入.

class pycuda.driver.HostAllocation#: 不赞成的名字 PagelockedHostAllocation .

对齐的主机内存#

pycuda.driver.aligned_empty(shape, dtype, order='C', alignment=4096)#

分配一个 numpy.ndarray 属于形状， D型和秩序，数据与对准字节。

有关其他参数的含义，请参阅 numpy 文档。

在 2011.1 版本加入.

pycuda.driver.aligned_zeros(shape, dtype, order='C', alignment=4096)#: 喜欢 aligned_empty() ，但初始化为零。

在 2011.1 版本加入.

pycuda.driver.aligned_empty_like(array, alignment=4096)#: 在 2011.1 版本加入.

pycuda.driver.aligned_zeros_like(array, alignment=4096)#: 在 2011.1 版本加入.

这个 numpy.ndarray 这些函数返回的实例具有一个属性 base 引用类型为

class pycuda.driver.AlignedHostAllocation#

继承自 HostPointer .

表示已对齐主机内存分配的对象。

free()#: 现在释放保留的内存，而不是当这个对象变得不可访问时。对象（或其关联对象）的任何进一步使用 numpy 数组）是一个错误，将导致未定义的行为。

分配后分页锁定#

pycuda.driver.register_host_memory(ary, flags=0)#

返回A numpy.ndarray 它与 ary . 只要这个函数的返回值是活动的，这个内存就会被页锁定。

返回数组的 base 属性包含 RegisteredHostMemory 实例，其 base 属性依次包含 ary .

CUDA 4.0及更新版本。

ary 的数据地址和大小必须与页对齐。实现这一点的一种方法是使用对齐的主机内存 .

在 2011.1 版本加入.

class pycuda.driver.RegisteredHostMemory#

继承自 HostPointer .

CUDA 4.0及更新版本。

在 2011.1 版本加入.

unregister()#: 注销此实例所持有的主机内存上的页锁。注意，这不会释放内存，只会释放页锁。

base#: 包含构建该实例的Python对象。

class pycuda.driver.HostPointer#

表示页锁定的主机指针。

get_device_pointer()#

返回一个设备指针，指示此内存映射到设备地址空间的地址。

仅适用于CUDA 2.2及更新版本。

托管内存#

cuda 6.0增加了对“统一内存”模型的支持，该模型创建了一个对cpu和gpu都可见的托管虚拟内存空间。操作系统将根据需要在CPU和GPU之间迁移与托管内存相关的物理页。这允许将主机上的numpy数组传递到内核，而无需首先创建设备分配并手动将主机数据复制到设备和从设备复制主机数据。

备注

托管内存仅适用于CUDA设备、操作系统和主机编译器目标体系结构的某些组合。有关详细信息，请参阅CUDA C编程指南和CUDA发行说明。

警告

这个到托管内存的接口应该被认为是实验性的。它是作为一个预览版提供的，但目前与pycuda的其余部分一样的接口稳定性保证并不适用。

托管内存分配#

pycuda.driver.managed_empty(shape, dtype, order='C', mem_flags=0)#

分配托管 numpy.ndarray 属于形状， D型和秩序 .

mem_flags 可能是 mem_attach_flags .

有关其他参数的含义，请参阅 numpy 文档。

仅适用于CUDA 6.0及更新版本。

在 2014.1 版本加入.

pycuda.driver.managed_zeros(shape, dtype, order='C', mem_flags=0)#

喜欢 managed_empty() ，但初始化为零。

仅适用于CUDA 6.0及更新版本。

在 2014.1 版本加入.

pycuda.driver.managed_empty_like(array, mem_flags=0)#: 仅适用于CUDA 6.0及更新版本。

在 2014.1 版本加入.

pycuda.driver.managed_zeros_like(array, mem_flags=0)#: 仅适用于CUDA 6.0及更新版本。

在 2014.1 版本加入.

这个 numpy.ndarray 这些函数返回的实例具有一个属性 base 引用类型为

class pycuda.driver.ManagedAllocation#

表示托管主机内存分配的对象。删除此对象后，将释放其关联的CUDA托管内存。

free()#: 现在释放保留的内存，而不是当这个对象变得不可访问时。对象（或其关联对象）的任何进一步使用 numpy 数组）是一个错误，将导致未定义的行为。

get_device_pointer()#: 返回一个设备指针，指示此内存映射到设备地址空间的地址。对于托管内存，这也是主机指针。

attach(mem_flags, stream=None)#: 将托管分配的可见性更改为 mem_attach_flags . 托管数组可以对主机CPU和整个CUDA上下文可见。 mem_attach_flags.GLOBAL ，或仅限于CPU mem_attach_flags.HOST . 如果 mem_attach_flags.SINGLE 如果选中，则数组将仅对CPU和提供的 Stream .

托管内存使用#

托管numpy数组的构造和在主机上的使用方式与pagelocked数组类似：

from pycuda.autoinit import context
import pycuda.driver as cuda
import numpy as np

a = cuda.managed_empty(shape=10, dtype=np.float32, mem_flags=cuda.mem_attach_flags.GLOBAL)
a[:] = np.linspace(0, 9, len(a)) # Fill array on host

它可以被传递给GPU内核，并且在没有显式拷贝的情况下再次使用在主机上：

from pycuda.compiler import SourceModule
mod = SourceModule("""
__global__ void doublify(float *a)
{
    a[threadIdx.x] *= 2;
}
""")
doublify = mod.get_function("doublify")

doublify(a, grid=(1,1), block=(len(a),1,1))
context.synchronize() # Wait for kernel completion before host access

median = np.median(a) # Computed on host!

警告

CUDA统一内存模型对于托管内存分配的并发访问有非常具体的规则。当GPU执行内核时，不允许主机访问任何托管阵列，无论正在运行的内核是否正在使用该阵列。不遵循并发规则会产生分段错误， 导致python解释器立即终止 .

受管numpy阵列的用户应该阅读cuda c编程指南的“统一内存编程”附录，以了解有关并发限制的更多详细信息。

如果由于并发问题而遇到解释器终止，则 faulthandler <http://pypi.python.org/pypi/faulthandler> 模块可能有助于确定python程序中发生错误访问的位置。

阵列和纹理#

class pycuda.driver.ArrayDescriptor#

width#

height#

format#: 类型值 array_format .

num_channels#

class pycuda.driver.ArrayDescriptor3D#

width#

height#

depth#

format#: 类型值 array_format . 仅限CUDA 2.0及以上版本。

num_channels#

class pycuda.driver.Array(descriptor)#

只能通过纹理引用访问的2D或3D存储块。

描述符 可以是类型的 ArrayDescriptor 或 ArrayDescriptor3D .

free()#: 现在释放阵列及其设备内存，而不是在无法访问此对象时释放。任何对对象的进一步使用都是一个错误，将导致未定义的行为。

get_descriptor()#: 返回A ArrayDescriptor 这个2D数组的对象，就像用来创建它的那个对象一样。

get_descriptor_3d()#: 返回A ArrayDescriptor3D 这个3D数组的对象，就像用来创建它的那个一样。仅限CUDA 2.0及以上版本。

handle#: 返回一 int 表示此数组所在的设备内存中的地址。

class pycuda.driver.SurfaceReference#

备注

该类的实例只能通过 Module.get_surfref() .

CUDA 3.1及以上。

在 0.94 版本加入.

set_array(array, flags=0)#

Bind self to the Array array.

只要数组仍然绑定到此纹理引用，它将不会被释放--纹理引用保留对数组的引用。

get_array()#: 找回 Array 向哪个 self 是绑定的。

备注

这将是与传递给的对象不同的对象 set_array() ，但它将比较相等。

class pycuda.driver.TextureReference#

对线性内存或 Array 一个纹理单位。

set_array(array)#

Bind self to the Array array.

只要数组仍然绑定到此纹理引用，它将不会被释放--纹理引用保留对数组的引用。

set_address(devptr, bytes, allow_offset=False)#

束缚 self 从整数地址开始的一块线性内存 德普特 ，包含许多字节 . 由于对齐要求，有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法以字节为单位返回此偏移量。如果 allow_offset 是 False ，此偏移量的非零值将导致引发异常。

不像 Array 对象，没有为绑定到纹理引用的线性内存提供生命支持。

set_address_2d(devptr, descr, pitch)#: Bind self as a 2-dimensional texture to a chunk of global memory at devptr. The line-to-line offset in bytes is given by pitch. Width, height and format are given in the ArrayDescriptor descr. set_format() need not and should not be called in addition to this method.

set_format(fmt, num_components)#: Set the texture to have array_format fmt and to have num_components channels.

set_address_mode(dim, am)#: 设置维度的地址模式 dim 到 am ，它必须是 address_mode 价值观。

set_flags(flags)#: 将标志设置为 TRSF_XXX 价值观。

get_array()#: 找回 Array 向哪个 self 是绑定的。

备注

这将是与传递给的对象不同的对象 set_array() ，但它将比较相等。

get_address_mode(dim)#

get_filter_mode()#

get_format()#

返回元组 (fmt, num_components) 在哪里 fmt 属于类型 array_format 和 num_components 是此纹理中的通道数。

（仅限2.0及以上版本。）

get_flags()#

pycuda.driver.TRSA_OVERRIDE_FORMAT#

pycuda.driver.TRSF_READ_AS_INTEGER#

pycuda.driver.TRSF_NORMALIZED_COORDINATES#

pycuda.driver.TR_DEFAULT#

pycuda.driver.matrix_to_array(matrix, order)#: 转动二维 numpy.ndarray 对象矩阵变成一个 Array . 这个 order 参数可以是 "C" 或 "F" . 如果是 "C" 然后 tex2D(x,y) 要去拿 matrix[y,x] ，反之亦然 "F" .

pycuda.driver.np_to_array(nparray, order, allowSurfaceBind=False)#

转A numpy.ndarray 在二维或三维结构中， Array . 这个 order 参数可以是 "C" 或 "F" .如果 allowSurfaceBind 传递为 True 归还的人 Array 可以读写 SurfaceReference 除了阅读 TextureReference . 功能自动检测 D型并将频道调整为支持 array_format . 还添加了对 np.float64 ， np.complex64 和 np.complex128 格式。

使用示例：

#include <pycuda-helpers.hpp>

texture<fp_tex_double, 3, cudaReadModeElementType> my_tex; // complex128: fp_tex_cdouble
                                                           // complex64 : fp_tex_cfloat
                                                           // float64   : fp_tex_double
surface<void, 3, cudaReadModeElementType> my_surf;         // Surfaces in 2D needs 'cudaSurfaceType2DLayered'

__global__ void f()
{
  ...
  fp_tex3D(my_tex, i, j, k);
  fp_surf3Dwrite(myvar, my_surf, i, j, k, cudaBoundaryModeClamp); // fp extensions don't need width in bytes
  fp_surf3Dread(&myvar, my_surf, i, j, k, cudaBoundaryModeClamp);
  ...
}

在 2015.1 版本加入.

pycuda.driver.gpuarray_to_array(gpuparray, order, allowSurfaceBind=False)#: 转A GPUArray 在二维或三维结构中， Array . 相同的结构和用途 np_to_array()

在 2015.1 版本加入.

pycuda.driver.make_multichannel_2d_array(matrix, order)#

旋转三维 numpy.ndarray 对象矩阵进入2D Array 有多个频道。

取决于 order , the matrix 的形状解释为

height, width, num_channels 对于 order == "C" ，
num_channels, width, height 对于 order == "F" .

备注

此函数假定矩阵已使用内存顺序创建秩序 . 如果不是这样，那么复制的数据很可能不是您所期望的。

初始化设备内存#

pycuda.driver.memset_d8(dest, data, count)#

pycuda.driver.memset_d16(dest, data, count)#

pycuda.driver.memset_d32(dest, data, count)#: 将数组填充为 data 。

备注

计数是元素数，而不是字节数。

pycuda.driver.memset_d2d8(dest, pitch, data, width, height)#

pycuda.driver.memset_d2d16(dest, pitch, data, width, height)#

pycuda.driver.memset_d2d32(dest, pitch, data, width, height)#: 用以下内容填充二维数组 data 。

pycuda.driver.memset_d8_async(dest, data, count, stream=None)#

pycuda.driver.memset_d16_async(dest, data, count, stream=None)#

pycuda.driver.memset_d32_async(dest, data, count, stream=None)#: 将数组填充为 data 异步地、可选地通过 stream 。

在 2015.1 版本加入.

pycuda.driver.memset_d2d8_async(dest, pitch, data, width, height, stream=None)#

pycuda.driver.memset_d2d16_async(dest, pitch, data, width, height, stream=None)#

pycuda.driver.memset_d2d32_async(dest, pitch, data, width, height, stream=None)#: 用以下内容填充二维数组 data 异步地、可选地通过 stream 。

在 2015.1 版本加入.

非结构化内存传输#

pycuda.driver.memcpy_htod(dest, src)#: 从python缓冲区复制 src 指向设备指针 dest （安） int 或A DeviceAllocation ）副本的大小由缓冲区的大小决定。

pycuda.driver.memcpy_htod_async(dest, src, stream=None)#

从python缓冲区复制 src 指向设备指针 dest （安） int 或A DeviceAllocation ）异步、可选地通过流动 . 副本的大小由缓冲区的大小决定。

src 必须是页锁定内存，请参见，例如。 pagelocked_empty() .

0.93新。

pycuda.driver.memcpy_dtoh(dest, src)#: 从设备指针复制 src （安） int 或A DeviceAllocation ）到python缓冲区 dest . 副本的大小由缓冲区的大小决定。

pycuda.driver.memcpy_dtoh_async(dest, src, stream=None)#

从设备指针复制 src （安） int 或A DeviceAllocation ）到python缓冲区 dest 异步、可选地通过流动 . 副本的大小由缓冲区的大小决定。

dest 必须是页锁定内存，请参见，例如。 pagelocked_empty() .

0.93新。

pycuda.driver.memcpy_dtod(dest, src, size)#

pycuda.driver.memcpy_dtod_async(dest, src, size, stream=None)#: CUDA 3.0及以上。

在 0.94 版本加入.

pycuda.driver.memcpy_peer(dest, src, size, dest_context=None, src_context=None)#

pycuda.driver.memcpy_peer_async(dest, src, size, dest_context=None, src_context=None, stream=None)#: CUDA 4.0及以上。

在 2011.1 版本加入.

pycuda.driver.memcpy_dtoa(ary, index, src, len)#

pycuda.driver.memcpy_atod(dest, ary, index, len)#

pycuda.driver.memcpy_htoa(ary, index, src)#

pycuda.driver.memcpy_atoh(dest, ary, index)#

pycuda.driver.memcpy_atoa(dest, dest_index, src, src_index, len)#

结构化内存传输#

class pycuda.driver.Memcpy2D#

src_x_in_bytes#: 副本原点的X偏移量。（初始化为0）

src_y#: 副本原点的Y偏移。（初始化为0）

src_pitch#: 副本原始位置的行大小（字节）。

set_src_host(buffer)#: 设置 缓冲区 ，它必须是附加到缓冲区接口的python对象，才能作为副本的源。

set_src_array(array)#: Set the Array array to be the origin of the copy.

set_src_device(devptr)#: 设置设备地址 德普特 （安） int 或A DeviceAllocation ）作为副本的来源。

set_src_unified(buffer)#

等同于 set_src_host() 除了 缓冲区 也可以对应于设备存储器。

CUDA 4.0及以上。需要统一寻址。

在 2011.1 版本加入.

dst_x_in_bytes#: 副本目标的X偏移量。（初始化为0）

dst_y#: 副本目标的Y偏移量。（初始化为0）

dst_pitch#: 副本目标处的行大小（字节）。

set_dst_host(buffer)#: 设置 缓冲区 ，它必须是附加到缓冲区接口的python对象，才能作为副本的目标。

set_dst_array(array)#: Set the Array array to be the destination of the copy.

set_dst_device(devptr)#: 设置设备地址 德普特 （安） int 或A DeviceAllocation ）作为副本的目的地。

set_dst_unified(buffer)#

等同于 set_dst_host() 除了 缓冲区 也可以对应于设备存储器。

CUDA 4.0及以上。需要统一寻址。

在 2011.1 版本加入.

width_in_bytes#: 要为传输中的每一行复制的字节数。

height#: 要复制的行数。

__call__([aligned=True])#: 执行指定的内存复制，等待它完成。如果 对齐的 是假，对于可能导致复制带宽丢失的设备到设备的复制，请允许设备端不对齐。

__call__(stream): Perform the memory copy asynchronously, serialized via the Stream stream. Any host memory involved in the transfer must be page-locked.

class pycuda.driver.Memcpy3D#

Memcpy3D 成员与 Memcpy2D ，以及以下所有内容：

src_height#: 当源是 Array . 如果深度=1，则可以为0。

src_z#: 副本原点的Z偏移。（初始化为0）

dst_height#: 当目标是 Array . 如果深度=1，则可以为0。

dst_z#: 副本目标的Z偏移量。（初始化为0）

depth#

Memcpy3D 仅在CUDA 2.0及更高版本上受支持。

class pycuda.driver.Memcpy3DPeer#

Memcpy3DPeer 成员与 Memcpy3D ，以及以下所有内容：

set_src_context(ctx)#

set_dst_context(ctx)#

CUDA 4.0及更新版本。

在 2011.1 版本加入.

设备上的代码：模块和功能#

class pycuda.driver.Module#

加载到设备上的cubin模块的句柄。可以创建与 module_from_file() 和 module_from_buffer() .

get_function(name)#: Return the Function name in this module.

警告

虽然可以使用此方法获得同一函数的不同句柄，但这些句柄都共享通过 set_XXX 方法 Function . 这意味着不能获得同一函数的两个不同句柄。 Function.prepare() 有两种不同的方式。

get_global(name)#

返回元组 (device_ptr, size_in_bytes) 提供全局的设备地址和大小 name .

此方法的主要用途是查找预先声明的 __constant__ 数组，以便在内核调用之前从主机中填充它们。

get_texref(name)#: Return the TextureReference name from this module.

get_surfref(name)#

Return the SurfaceReference name from this module.

CUDA 3.1及以上。

在 0.94 版本加入.

pycuda.driver.module_from_file(filename)#: 创建一个 Module 通过加载cubin文件 文件名 .

pycuda.driver.module_from_buffer(buffer, options=[], message_handler=None)#

创建一个 Module 通过从 缓冲区 ，它必须支持python缓冲区接口。（例如， str 和 numpy.ndarray 做。）

参数:

options -- 元组列表 (jit_option 价值。
message_handler -- 可调用的，用 (compile_success_bool, info_str, error_str) 它允许用户处理来自ptx编译器的错误和警告消息。

加载ptx模块以及选项和 message_handler 只允许在CUDA 2.1和更新版本上使用。

class pycuda.driver.Function#

句柄 __global__ A中的函数 Module . 创建使用 Module.get_function() .

__call__(arg1, ..., argn, block=block_size[, grid=(1, 1)[, stream=None[, shared=0[, texrefs=[][, time_kernel=False]]]]])#

发射 self ，线程块大小为块 . 块必须是3元组整数。

arg1 通过 argn 是内核的位置c参数。见 param_set() 详细情况。尤其是那里的警告。

grid 以最多三个整数条目的元组形式指定要启动的线程块的数量，作为多维网格。 stream ，如果指定，则为 Stream 实例序列化输入参数的复制(如果有)、执行和输出参数的复制(同样，如果有)。 shared 中可供内核使用的字节数。 extern __shared__ 数组。 texrefs 是一种 list 的 TextureReference 函数将有权访问的实例。

函数返回 None 或执行内核所用的秒数，具体取决于 time_kernel 是 True .

这是一个方便的接口，可以用来代替 param_*() 和 launch_*() 方法如下。有关调用内核的更快（但稍微不太方便）方法，请参见 prepare() 和 prepared_call() .

arg1 通过 argn 允许具有以下类型：

亚类 numpy.number . 这些是大小数字类型，如 numpy.uint32 或 numpy.float32 .
DeviceAllocation 实例，它将成为指向已分配内存的设备指针。
实例 ArgumentHandler 子类。这些可以用于自动传输。 numpy 阵列在设备上和设备上。
支持python的对象 buffer 接口。这些字节块将逐字复制到参数空间中。
GPUArray 实例。

警告

不能传递python的本机值 int 或 float 要设置参数的类型。因为没有明确的方法来猜测这些整数或浮点数的大小，所以它用 TypeError .

备注

这个方法必须猜测传递给它的参数的类型，这会使它有点慢。对于一个经常被调用的内核，这可能是不方便的。有关调用内核的更快（但稍微不太方便）方法，请参见 prepare() 和 prepared_call() .

备注

grid 对于两个以上的维度，需要CUDA 4.0或更高版本。

param_set_texref(texref)#: 使 TextureReference 函数可用的texref。

prepare(arg_types, shared=None, texrefs=[])#

准备调用此函数

将参数类型设置为 arg_types . arg_types 应为iterable，包含 struct 模块或 numpy.dtype 物体。

（此外，皮库达明白 'F' 和 'D' 对于单精度和双精度浮点数。）
注册纹理引用 texrefs 用于此功能。这个 TextureReference 中的对象 texrefs 将被保留，并且无论这些引用在调用时绑定到什么，都将通过内核中相应的纹理引用可用。

返回 self .

prepared_call(grid, block, *args, shared_size=0)#: 援引 self 使用 launch_grid() 用 args 网格大小为 grid ，块大小为块 . 假定 prepare() 被召唤 self . 给定的纹理引用 prepare() 也设置为参数。

在 2012.1 版本发生变更: shared_size 加入。

prepared_timed_call(grid, block, *args, shared_size=0)#

援引 self 使用 launch_grid() 用 args ，网格大小为 grid ，块大小为块 . 假定 prepare() 被召唤 self . 给定的纹理引用 prepare() 也设置为参数。

返回一个0进制可调用，可用于查询调用所消耗的GPU时间，以秒为单位。一旦调用，这个可调用的将阻塞，直到调用完成。

在 2012.1 版本发生变更: shared_size 加入。

prepared_async_call(grid, block, stream, *args, shared_size=0)#: 援引 self 使用 launch_grid_async() 用 args ，网格大小为 grid ，块大小为块，序列化为 pycuda.driver.Stream stream . 如果 stream 如果没有，请按照 prepared_call() . 假定 prepare() 被召唤 self . 给定的纹理引用 prepare() 也设置为参数。

在 2012.1 版本发生变更: shared_size 加入。

get_attribute(attr)#

返回 function_attribute 价值 attr .

所有 function_attribute 值也可以直接读取为 Function 对象本身，例如 func.num_regs .

CUDA 2.2及更新版本。

在 0.93 版本加入.

set_attribute(attr, value)#: 设置由给定的(可设置)属性之一 function_attribute 价值 attr 至 value 。

在 2022.1 版本加入.

set_cache_config(fc)#

见 func_cache 对于可能的值 fc .

CUDA 3.0（测试后）及更新版本。

在 0.94 版本加入.

set_shared_config(sc)#

见 shared_config 对于可能的值 sc .

CUDA 4.2及更新版本。

在 2013.1 版本加入.

local_size_bytes#

此函数使用的本地内存字节数。

在CUDA 2.1及以下版本中，仅当此功能是 pycuda.compiler.SourceModule . 它替换了现在已弃用的属性 lmem .

shared_size_bytes#

此函数使用的共享内存字节数。

在CUDA 2.1及以下版本中，仅当此功能是 pycuda.compiler.SourceModule . 它替换了现在已弃用的属性 smem .

num_regs#

此函数使用的32位寄存器数。

在CUDA 2.1及以下版本中，仅当此功能是 pycuda.compiler.SourceModule . 它替换了现在已弃用的属性 registers .

set_shared_size(bytes)#: 集合共享为内核可用的字节数 extern __shared__ 数组。

警告

自2011.1版起已弃用。

set_block_shape(x, y, z)#: 设置此函数的线程块形状。

警告

自2011.1版起已弃用。

param_set(arg1, ... argn)#: 设置此函数的线程块形状。

警告

自2011.1版起已弃用。

param_set_size(bytes)#: 将参数空间调整为字节 .

警告

自2011.1版起已弃用。

param_seti(offset, value)#: 将整数设置为抵消在参数空间中价值 .

警告

自2011.1版起已弃用。

param_setf(offset, value)#: 将浮动设置为抵消在参数空间中价值 .

警告

自2011.1版起已弃用。

launch()#: 启动 self .

警告

自2011.1版起已弃用。

launch_grid(width, height)#: 展开宽度 线程块高度网格 自我*

警告

自2011.1版起已弃用。

launch_grid_async(width, height, stream)#: 展开宽度 线程块高度网格 自己 , sequenced by the :class:`Stream` * 流。

警告

自2011.1版起已弃用。

class pycuda.driver.ArgumentHandler(array)#

class pycuda.driver.In(array)#: Inherits from ArgumentHandler. Indicates that buffer array should be copied to the compute device before invoking the kernel.

class pycuda.driver.Out(array)#: Inherits from ArgumentHandler. Indicates that buffer array should be copied off the compute device after invoking the kernel.

class pycuda.driver.InOut(array)#: Inherits from ArgumentHandler. Indicates that buffer array should be copied both onto the compute device before invoking the kernel, and off it afterwards.

剖面仪控件#

CUDA 4.0及更新版本。

pycuda.driver.initialize_profiler(config_file, output_file, output_mode)#: output_mode 是 profiler_output_mode .

在 2011.1 版本加入.

pycuda.driver.start_profiler()#: 在 2011.1 版本加入.

pycuda.driver.stop_profiler()#: 在 2011.1 版本加入.

即时编译#

pycuda.compiler.DEFAULT_NVCC_FLAGS#

在 2011.1 版本加入.

如果没有选项在下面的调用中，将使用此列表类型变量的值。这对于将必要的标志注入到自动编译的内核（如模块使用的内核）的编译中可能很有用。 pycuda.gpuarray .

此变量的初始值取自环境变量 PYCUDA_DEFAULT_NVCC_FLAGS .

如果在代码中修改此变量，请注意这是一个全局共享变量，可能会被多个包修改。在这种修改中请小心--你可能会破坏别人的代码。

class pycuda.compiler.SourceModule(source, nvcc='nvcc', options=None, keep=False, no_extern_c=False, arch=None, code=None, cache_dir=None, include_dirs=[])#

创建一个 Module 来自CUDA源代码来源 . nvidia编译器 nvcc 假设是在 PATH 如果未指定路径，则使用选项编译代码。如果 keep 是 True ，将保留编译器输出目录，并打印一行指示其在文件系统中的位置，以便进行调试。

除非 no_extern_c 是 True ，给定的源代码包装在 外部“c”{{…} 防止C++名称的篡改。

arch 和 code 指定要为 -arch 和 -code 选项 nvcc 命令行。如果 arch 是 None ，它默认为当前上下文的设备的计算能力。如果 code 是 None ，将不指定。

cache_dir 提供用于编译器缓存的目录。如果 None 然后 cache_dir 被认为是 PYCUDA_CACHE_DIR 如果设置或合理的每用户默认值。如果通过 False ，已禁用缓存。

如果环境变量 PYCUDA_DISABLE_CACHE 设置为任意值，则禁用缓存。此首选项将覆盖 cache_dir 并且可以用于禁用全局缓存。

这个类显示的公共接口与 pycuda.driver.Module ，但不从中继承。

更改注释： SourceModule 被搬离 pycuda.driver 到 pycuda.compiler 版本0.93。

compile(source, nvcc="nvcc", options=None, keep=False,
no_extern_c=False, arch=None, code=None, cache_dir=None,
include_dirs=[]): 执行与相应的 SourceModule 构造函数，但只返回结果库宾文件为字符串。特别是，不要将代码上传到gpu。

设备接口#

版本查询#

错误报告#

常量#

图形相关常数#

设备和上下文#

并发和流#

Memory#

全局设备内存#

分页锁定主机内存#

页面锁定分配#

对齐的主机内存#

分配后分页锁定#

托管内存#

托管内存分配#

托管内存使用#

阵列和纹理#

初始化设备内存#

非结构化内存传输#

结构化内存传输#

设备上的代码：模块和功能#

剖面仪控件#

即时编译#