NAME¶
Data_Types - OpenCL data types.
DESCRIPTION¶
These are the data types available in the OpenCL C programming language. Click
on a category name in the table below to see information about specific data
types.
Data type category |
Included data types |
scalarDataTypes(3clc) |
bool, char, cl_char, unsigned char,
uchar, cl_uchar, short, cl_short, unsigned
short, ushort, int, unsigned int, uint,
long, unsigned long, ulong, float,
half, size_t, ptrdiff_t, intptr_t,
uintptr_t, void, double, and half floating
point types. |
vectorDataTypes(3clc) |
charn, ucharn,
short n, ushortn,
int n, uintn,
longn, ulongn,
float n, doublen, and optional halfn
types. |
abstractDataTypes(3clc) |
cl_platform_id, cl_device_id, cl_context,
cl_command_queue, cl_mem, cl_program,
cl_kernel, cl_event, and cl_sampler. |
reservedDataTypes(3clc) |
booln, halfn, quad,
quad n, complex half, complex
half n, imaginary half, imaginary
half n, complex float, complex
float n, imaginary float, imaginary
floatn, complex double, complex
double n, imaginary double, imaginary
double n, complex quad, complex
quad n, imaginary quad, imaginary
quad n, floatnxm,
double nxm, long double, long
double n, long long, long
longn, unsigned long long, ulong long, and
ulong longn. |
otherDataTypes(3clc) |
image2d_t, image3d_t, image2d_array_t,
image1d_t, image31_buffer_t, image1d_array_t,
sampler_t, and event_t. |
ALIGNMENT OF TYPES¶
A data item declared to be a data type in memory is always aligned to the size
of the data type in bytes. For example, a
float4 variable will be
aligned to a 16-byte boundary, and a
char2 variable will be aligned to
a 2-byte boundary.
For 3-component vector data types, the size of the data type is 4 *
sizeof(component). This means that a 3-component vector data type will be
aligned to a 4 * sizeof(component) boundary. The
vloadn(3clc) and
vstoren(3clc) built-in functions can be used to read and write,
respectively, 3-component vector data types from an array of packed scalar
data type.
A built-in data type that is not a power of two bytes in size must be aligned to
the next larger power of two. This rule applies to built-in types only, not
structs or unions.
The OpenCL compiler is responsible for aligning data items to the appropriate
alignment as required by the data type. For arguments to a
functionQualifiers(3clc) function declared to be a pointer to a data
type, the OpenCL compiler can assume that the pointee is always appropriately
aligned as required by the data type. The behavior of an unaligned load or
store is undefined, except for the
vloadn(3clc),
vload_halfn(3clc),
vstoren(3clc), and
vstore_halfn(3clc)
functions. The vector load functions can read a vector from an address aligned
to the element type of the vector. The vector store functions can write a
vector to an address aligned to the element type of the vector.
The user is responsible for ensuring that data passed into and out of OpenCL
buffers are natively aligned relative to the start of the buffer as described
above. This implies that OpenCL buffers created with
CL_MEM_USE_HOST_PTR need to provide an appropriately aligned host
memory pointer that is aligned to the data types used to access these buffers
in a kernel(s). As well, the user is responsible to ensure that data passed
into and out of OpenCL images are properly aligned to the granularity of the
data representing a single pixel (e.g.
image_num_channels * sizeof(
image_channel_data_type)) except for
CL_RGB and
CL_RGBx
images where the data must be aligned to the granularity of a single channel
in a pixel (i.e. sizeof(
image_channel_data_type)).
OpenCL makes no requirement about the alignment of OpenCL application defined
data types outside of buffers and images, except that the underlying vector
primitives (e.g.
__cl_float4) where defined shall be directly
accessible as such using appropriate named fields in the
cl_type union.
Nevertheless, it is recommended that the cl_platform.h header should attempt
to naturally align OpenCL defined application data types (e.g.
cl_float4) according to their type.
SPECIFICATION¶
OpenCL Specification[1]
AUTHORS¶
The Khronos Group
COPYRIGHT¶
Copyright © 2007-2010 The Khronos Group Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and/or associated documentation files (the
"Materials"), to deal in the Materials without restriction,
including without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Materials, and to permit
persons to whom the Materials are furnished to do so, subject to the condition
that this copyright notice and permission notice shall be included in all
copies or substantial portions of the Materials.
NOTES¶
- 1.
- OpenCL Specification
page 195, section 6.1.1 - Built-in Scalar Data
Types