OpenCL 1.2架构与编程模型详解

5星 · 超过95%的资源需积分: 50 198 浏览量更新于2024-07-28 1 收藏 2.68MB PDF 举报

OpenCL 1.2 是 Khronos Group 发布的一个重要的并行计算标准，旨在提供跨平台的高性能计算能力，支持广泛的硬件设备，如GPU、CPU和加速器。此版本的文档详细介绍了 OpenCL 的架构、编程模型以及平台和运行时组件。 1. **架构与模型** - **平台模型 (Platform Model)**: OpenCL 1.2定义了平台的概念，它是由一个或多个设备组成的集合，每个设备可能有不同的特性（如计算能力、内存大小等）。平台支持混合版本，即同一平台上可能存在不同版本的设备。 - **执行模型 (Execution Model)**: 包括 **上下文和命令队列**，允许程序创建多个并行执行的环境。**数据并行编程模型**强调在一组处理器上同时处理相同的数据块，而**任务并行模型**则侧重于独立的任务分发给不同的处理器执行。 - **内存模型 (Memory Model)**: 关注内存一致性，即如何保证多线程或异步操作之间的数据可见性。OpenCL提供了内存空间划分，确保正确同步对共享数据的访问。 - **编程模型**: 包括数据并行、任务并行，以及同步机制，用于协调各个处理单元的工作。 2. **平台层 (The OpenCL Platform Layer)**: - **查询平台信息**: 开发者可以通过API获取关于平台、设备和驱动程序的基本信息，以便选择适合的设备进行开发。 - **查询设备**: 了解设备的具体功能、性能指标和特性，例如类型（GPU、CPU）、兼容性等。 - **设备分区 (Partitioning a Device)**: 可能涉及到将设备资源分配给特定的计算任务，优化性能和资源利用。 - **上下文 (Contexts)**: 每个上下文代表一个与一组设备关联的工作环境，可以创建多个上下文以支持并发执行。 3. **运行时 (The OpenCL Runtime)**: - **命令队列 (Command Queues)**: 开发者通过命令队列发送作业到特定的设备执行，提供控制并发和调度的能力。 - **缓冲对象 (Buffer Objects)**: 常见的数据结构，用于存储数据并在设备和主机之间传输。包括创建、读写和复制操作，以及填充缓冲对象的方法。 OpenCL 1.2规范为开发者提供了清晰的框架和接口，使得编写能在多种硬件平台上高效运行的并行代码成为可能。理解这些概念和细节对于有效利用OpenCL进行高性能计算至关重要。

Last Revision Date: 11/14/11 Page 16

Event Wait List: An event wait list is a list of event objects that can be used to control when a

particular command begins execution.

Framework: A software system that contains the set of components to support software

development and execution. A framework typically includes libraries, APIs, runtime systems,

compilers, etc.

Global ID: A global ID is used to uniquely identify a work-item and is derived from the number

of global work-items specified when executing a kernel. The global ID is a N-dimensional value

that starts at (0, 0, … 0). See also Local ID.

Global Memory: A memory region accessible to all work-items executing in a context. It is

accessible to the host using commands such as read, write and map.

GL share group: A GL share group object manages shared OpenGL or OpenGL ES resources

such as textures, buffers, framebuffers, and renderbuffers and is associated with one or more GL

context objects. The GL share group is typically an opaque object and not directly accessible.

Handle: An opaque type that references an object allocated by OpenCL. Any operation on an

object occurs by reference to that object’s handle.

Host: The host interacts with the context using the OpenCL API.

Host pointer: A pointer to memory that is in the virtual address space on the host.

Illegal: Behavior of a system that is explicitly not allowed and will be reported as an error when

encountered by OpenCL.

Image Object: A memory object that stores a two- or three- dimensional structured array.

Image data can only be accessed with read and write functions. The read functions use a

sampler.

The image object encapsulates the following information:

Dimensions of the image.

Description of each element in the image.

Properties that describe usage information and which region to allocate from.

Image data.

The elements of an image are selected from a list of predefined image formats.

Implementation Defined: Behavior that is explicitly allowed to vary between conforming

implementations of OpenCL. An OpenCL implementor is required to document the

implementation-defined behavior.

Last Revision Date: 11/14/11 Page 17

In-order Execution: A model of execution in OpenCL where the commands in a command-

queue are executed in order of submission with each command running to completion before the

next one begins. See Out-of-order Execution.

Kernel: A kernel is a function declared in a program and executed on an OpenCL device. A

kernel is identified by the __kernel or kernel qualifier applied to any function defined in a

program.

Kernel Object: A kernel object encapsulates a specific __kernel function declared in a

program and the argument values to be used when executing this __kernel function.

Local ID: A local ID specifies a unique work-item ID within a given work-group that is

executing a kernel. The local ID is a N-dimensional value that starts at (0, 0, … 0). See also

Global ID.

Local Memory: A memory region associated with a work-group and accessible only by work-

items in that work-group.

Marker: A command queued in a command-queue that can be used to tag all commands queued

before the marker in the command-queue. The marker command returns an event which can be

used by the application to queue a wait on the marker event i.e. wait for all commands queued

before the marker command to complete.

Memory Objects: A memory object is a handle to a reference counted region of global memory.

Also see Buffer Object and Image Object.

Memory Regions (or Pools): A distinct address space in OpenCL. Memory regions may

overlap in physical memory though OpenCL will treat them as logically distinct. The memory

regions are denoted as private, local, constant, and global.

Object: Objects are abstract representation of the resources that can be manipulated by the

OpenCL API. Examples include program objects, kernel objects, and memory objects.

Out-of-Order Execution: A model of execution in which commands placed in the work queue

may begin and complete execution in any order consistent with constraints imposed by event

wait lists and command-queue barrier. See In-order Execution.

Parent device: The OpenCL device which is partitioned to create sub-devices. Not all parent

devices are root devices. A root device might be partitioned and the sub-devices partitioned

again. In this case, the first set of sub-devices would be parent devices of the second set, but not

the root devices. Also see device, parent device and root device.

Platform: The host plus a collection of devices managed by the OpenCL framework that allow

an application to share resources and execute kernels on devices in the platform.

Last Revision Date: 11/14/11 Page 18

Private Memory: A region of memory private to a work-item. Variables defined in one work-

item’s private memory are not visible to another work-item.

Processing Element: A virtual scalar processor. A work-item may execute on one or more

processing elements.

Program: An OpenCL program consists of a set of kernels. Programs may also contain

auxiliary functions called by the __kernel functions and constant data.

Program Object: A program object encapsulates the following information:

A reference to an associated context.

A program source or binary.

The latest successfully built program executable, the list of devices for which the program

executable is built, the build options used and a build log.

The number of kernel objects currently attached.

Reference Count: The life span of an OpenCL object is determined by its reference count—an

internal count of the number of references to the object. When you create an object in OpenCL,

its reference count is set to one. Subsequent calls to the appropriate retain API (such as

clRetainContext, clRetainCommandQueue) increment the reference count. Calls to

the appropriate release API (such as clReleaseContext, clReleaseCommandQueue)

decrement the reference count. After the reference count reaches zero, the object’s resources are

deallocated by OpenCL.

Relaxed Consistency: A memory consistency model in which the contents of memory visible to

different work-items or commands may be different except at a barrier or other explicit

synchronization points.

Resource: A class of objects defined by OpenCL. An instance of a resource is an object. The

most common resources are the context, command-queue, program objects, kernel objects, and

memory objects. Computational resources are hardware elements that participate in the action

of advancing a program counter. Examples include the host, devices, compute units and

processing elements.

Retain, Release: The action of incrementing (retain) and decrementing (release) the reference

count using an OpenCL object. This is a book keeping functionality to make sure the system

doesn’t remove an object before all instances that use this object have finished. Refer to

Reference Count.

Root device: A root device is an OpenCL device that has not been partitioned. Also see device,

parent device and root device.

Sampler: An object that describes how to sample an image when the image is read in the kernel.

The image read functions take a sampler as an argument. The sampler specifies the image

Last Revision Date: 11/14/11 Page 19

addressing-mode i.e. how out-of-range image coordinates are handled, the filter mode, and

whether the input image coordinate is a normalized or unnormalized value.

SIMD: Single Instruction Multiple Data. A programming model where a kernel is executed

concurrently on multiple processing elements each with its own data and a shared program

counter. All processing elements execute a strictly identical set of instructions.

SPMD: Single Program Multiple Data. A programming model where a kernel is executed

concurrently on multiple processing elements each with its own data and its own program

counter. Hence, while all computational resources run the same kernel they maintain their own

instruction counter and due to branches in a kernel, the actual sequence of instructions can be

quite different across the set of processing elements.

Sub-device: An OpenCL device can be partitioned into multiple sub-devices. The new sub-

devices alias specific collections of compute units within the parent device, according to a

partition scheme. The sub-devices may be used in any situation that their parent device may be

used. Partitioning a device does not destroy the parent device, which may continue to be used

along side and intermingled with its child sub-devices. Also see device, parent device and root

device.

Task Parallel Programming Model: A programming model in which computations are

expressed in terms of multiple concurrent tasks where a task is a kernel executing in a single

work-group of size one. The concurrent tasks can be running different kernels.

Thread-safe: An OpenCL API call is considered to be thread-safe if the internal state as

managed by OpenCL remains consistent when called simultaneously by multiple host threads.

OpenCL API calls that are thread-safe allow an application to call these functions in multiple

host threads without having to implement mutual exclusion across these host threads i.e. they are

also re-entrant-safe.

Undefined: The behavior of an OpenCL API call, built-in function used inside a kernel or

execution of a kernel that is explicitly not defined by OpenCL. A conforming implementation is

not required to specify what occurs when an undefined construct is encountered in OpenCL.

Work-group: A collection of related work-items that execute on a single compute unit. The

work-items in the group execute the same kernel and share local memory and work-group

barriers.

Work-group Barrier. See Barrier.

Work-item: One of a collection of parallel executions of a kernel invoked on a device by a

command. A work-item is executed by one or more processing elements as part of a work-group

executing on a compute unit. A work-item is distinguished from other executions within the

collection by its global ID and local ID.

剩余376页未读，继续阅读

MisterMoon

粉丝: 0
资源: 1

OpenCL 1.2架构与编程模型详解

OpenCL 1.2 深入解析与编程指南

OpenCL 1.2 快速参考指南

OpenCL 1.2架构与编程模型详解

opencl-1.2.zip_OPENCL 1.2_OpencL

OPENCL1.2 标准

OPENCL1.2中文翻译版

TF-香菜：Tensorflow的OpenCL 1.2实现

QtOpenCLExamples:Qt5 + OpenCL 1.2 使用示例

OpenCL 1.2 规范 中文公测版第二版

OpenCL 1.2 异构编程指南

最新资源

OpenCL 1.2 规范中文公测版第二版