本文主要是介绍关于粗大的纹理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
General-purpose programming on GPU
First steps in CUDA
Giuseppe Bilotta, Eugenio Rustico, Alexis Hérault
DMI — Università di Catania
Sezione di Catania — INGV
Vector types
CUDA has built-in support for vector types: multi-dimensional data with 1 to 4 components, addressed by .x, .y, .z, .w. Some definitions:
struct uchar1
{unsigned char x;
};struct __align__(4) ushort2
{unsigned short x, y;
};struct uint3
{unsigned int x, y, z;
};struct __builtin_align__(16) float4
{float x, y, z, w;
};You can make them available in CPU code by including the appropriate header:
#include <vector_types.h>Example usages:
- images with 8-bit color (
uchar3) (RGB => x, y, z); - images with 32-bit color and transparency (
uint4) (RGBA => x, y, z, w); - particle systems (
float3) (x, y, z: physical coordinates);
Texture memory
3D graphics uses textures to ‘draw’ fancy stuff on 3D surfaces. Texture allocation and reading are also made available to the computing part of a GPU and can improve memory access or reduce computations in some use cases.
Kernels only have read-only access to texture memory. Reading a texel (texture element) is done with a fetch at given coordinates on atexture reference.
Before it can be used, a texture reference must be bound to a memory region. Binding is done by the CPU. Multiple texture references can be bound to the same or to overlapping memory areas.
A texture reference can have one, two or three dimensions. They can be bound either to standard linear memory addresses, or to special memory allocations called CUDA Arrays.
Texture references can only be used for integers (signed and unsigned, 8-, 16- or 32-bit wide), floats, and for the corresponding 1-, 2- and 4-component (but not 3-component) vector types.
Normalization of the values (mapping the value range to [0.0, 1.0] or [-1.0, 1.0]) can also be done automatically by texture references for 8-bit or 16-bit signed and unsigned integers. In this mode, for example, an unsigned 8-bit value of 0xcd (decimal 205) will be fetched as 0.803921569f (205/255).
Texture coordinates are floats in the range [0, N) where N is the texture size in that dimension. Example: a 64×32 texture will have coordinates [0,63]×[0,31]. Textures can be set to use normalized coordinates, mapping the actual size to [0, 1) in all dimensions.
Out-of-bounds coordinates are clamped, i.e. replaced with the closest in-bound coordinate. Example: a fetch for (-3.3, 33.3) on the previous texture would retrieve (0, 31). With normalized coordinates, textures can be set to wrap out of bounds coordinates. A fetch for (1.25, -1.25) would retrieve (0.25, 0.75).
Coordinates that do not fall exactly on a texel can return either the nearest neighbour or a value interpolated linearly from the neighbouring texels.
Some high-level examples. A 1-dimensional texture of float elements, returning the corresponding element type:
texture<float, 1, cudaReadModeElementType> posTex; A 2-dimensional texture of char4 elements, returning a float4 with components in [-1.0, 1.0]:
texture<char4, 2, cudaReadModeNormalizedFloat> pixTex;Texture references are always static (they have file scope) and must be global (i.e. do not declare them inside a function or structure).
The texture<> construct is a high-level interface to the structure
struct textureReference {int normalized;enum cudaTextureFilterMode filterMode;enum cudaTextureAddressMode addressMode[3];struct cudaChannelFormatDesc channelDesc;
} that allow you to choose if you want to normalize coordinates (normalized = 1), interpolate coordinates (filterMode = cudaFilterModeLinear) or set out-of-bounds coordinates to wrap in any particular direction (addressMode[i] = cudaAddressModeWrap).
Binding textures
Examples for binding textures to linear memory:
texture<float, 1> oneTex;
texture<float, 2> twoTex;
float *dVector;cudaMalloc(&dVector, width*height*sizeof(float));
cudaBindTexture(NULL, oneTex, dVector, vecsize);
cudaBindTexture2D(NULL, twoTex, dVector, twoTex.channelDesc,width, height, pitch);
cudaUnbindTexture(twoTex);
cudaUnbindTexture(oneTex); In the 2D case it is necessary to specify the pitch, i.e. the byte length of a row. This is typically width*sizeof(element), but may be larger is the rows are padded in memory to ensure a given alignment.
The first parameter is used to retrieve the offset that must be used to access elements, but it's only needed when the memory was not allocated with cudaMalloc (e.g. a texture pointing to a subset of an existing memory area) to comply with the memory alignment requirements of textures.
Transposing an image, with and without textures:
- CPU code to transpose an image
- GPU code to transpose an image (no textures)
- GPU code to transpose an image (1D textures)
- GPU code to transpose an image (2D textures)
Further texture examples: increasing the depth of an image, and various address modes
- include file to read/write images in PAM format
- example PAM image
- base GPU code with 8-to-16 bitdepth conversion
- further texture usage examples
PAM is a simple but flexible uncompressed bitmap format developed within the netpbm image manipulation toolkit . ImageMagick can be used to display and convert PAM images.
CUDA Arrays
CUDA arrays are memory areas dedicate to textures. They are read-only for the GPU (and are only accessible through texture fetches), and can be written to by the CPU using cudaMemcpyToArray. Devices with capability 2.0 or higher can write to CUDA arrays using surfaces, a read-write feature similar to textures.
Allocating a CUDA array requires the specification of a channel format description matching the one used by the texture that needs to be mapped on it.
Allocation:
texture<> someTex;
cudaArray *dArray;
cudaMallocArray(&dArray, &someTex.channelDesc, width, height); Use (can copy at an offset wo, ho in the array):
cudaMemcpyToArray(dArray, wo, ho, source, size, cudaMemcpyHostToDevice);
cudaBindTextureToArray(someTex, dArray);Release:
cudaFreeArray(dArray);The channel format description
The cudaChannelFormatDesc describes the format of a texture element.
struct cudaChannelFormatDesc {int x, y, z, w;enum cudaChannelFormatKind f;
} where x, y, z, w are set to the number of bits for each component, and f is one of cudaChannelFormatKindSigned,cudaChannelFormatKindUnsigned, cudaChannelFormatKindFloat.
Example, for float texels we could create a channel with
cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat); while for short4 texels this would be
cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSigned);这篇关于关于粗大的纹理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
