版本记录
| 版本号 | 时间 |
|---|---|
| V1.0 | 2018.10.09 星期二 |
前言
很多做视频和图像的，相信对这个框架都不是很陌生，它渲染高级3D图形，并使用GPU执行数据并行计算。接下来的几篇我们就详细的解析这个框架。感兴趣的看下面几篇文章。
1. Metal框架详细解析（一）—— 基本概览
2. Metal框架详细解析（二） —— 器件和命令（一）
3. Metal框架详细解析（三） —— 渲染简单的2D三角形（一）
4. Metal框架详细解析（四） —— 关于GPU Family 4（一）
5. Metal框架详细解析（五） —— 关于GPU Family 4之关于Imageblocks（二）
6. Metal框架详细解析（六） —— 关于GPU Family 4之关于Tile Shading（三）
7. Metal框架详细解析（七） —— 关于GPU Family 4之关于光栅顺序组（四）
8. Metal框架详细解析（八） —— 关于GPU Family 4之关于增强的MSAA和Imageblock采样覆盖控制（五）
9. Metal框架详细解析（九） —— 关于GPU Family 4之关于线程组共享（六）
10. Metal框架详细解析（十） —— 基本组件（一）
11. Metal框架详细解析（十一） —— 基本组件之器件选择 - 图形渲染的器件选择（二）
12. Metal框架详细解析（十二） —— 基本组件之器件选择 - 计算处理的设备选择（三）
13. Metal框架详细解析（十三） —— 计算处理（一）
14. Metal框架详细解析（十四） —— 计算处理之你好，计算（二）
15. Metal框架详细解析（十五） —— 计算处理之关于线程和线程组（三）
16. Metal框架详细解析（十六） —— 计算处理之计算线程组和网格大小（四）
17. Metal框架详细解析（十七） —— 工具、分析和调试（一）
18. Metal框架详细解析（十八） —— 工具、分析和调试之Metal GPU Capture（二）
19. Metal框架详细解析（十九） —— 工具、分析和调试之GPU活动监视器（三）
20. Metal框架详细解析（二十） —— 工具、分析和调试之关于Metal着色语言文件名扩展名、使用Metal的命令行工具构建库和标记Metal对象和命令（四）
21. Metal框架详细解析（二十一） —— 基本课程之基本缓冲区（一）
22. Metal框架详细解析（二十二） —— 基本课程之基本纹理（二）
23. Metal框架详细解析（二十三） —— 基本课程之CPU和GPU同步（三）
24. Metal框架详细解析（二十四） —— 基本课程之参数缓冲 - 基本参数缓冲（四）
Argument Buffers with Arrays and Resource Heaps - 带有数组和资源堆的参数缓冲区
演示如何使用数组定义参数缓冲区，并通过将参数缓冲区与资源堆组合来减少CPU开销。
在Basic Argument Buffers示例中，您学习了如何在参数缓冲区中指定，编码，设置和访问资源。
在此示例中，您将学习如何将参数缓冲区与资源数组和资源堆组合在一起。 特别是，您将学习如何定义包含数组的参数缓冲区结构以及如何从堆中分配和使用资源。 该示例渲染了一个静态四边形，它使用编码到参数缓冲区中的多个资源。
Arrays of Arguments in the Metal Shading Language - Metal着色语言中的参数数组
数组可用作图形或计算函数的参数。 当函数将数组作为参数时，数组中第一个资源的索引等于数组参数本身的基本索引。 因此，数组中的每个后续资源都会自动分配一个后续索引值，从基本索引值开始递增计数。
例如，以下片段函数exampleFragmentFunction有一个参数textureParameters，它是一个包含10个纹理的数组，其基本索引值为5。
fragment float4
exampleFragmentFunction(array<texture2d<float>, 10> textureParameters [[ texture(5) ]])
因为textureParameters具有[[texture（5）]]属性限定符，所以设置此参数的相应Metal框架方法是setFragmentTexture：atIndex：，其中index的值从5开始。因此，数组索引0处的纹理设置为索引号5，数组索引1处的纹理设置为索引号6，依此类推。 阵列索引为9的数组中的最后一个纹理设置为索引号14。
Define Argument Buffers with Arrays - 使用数组定义参数缓冲区
数组也可以用作参数缓冲结构的元素。 在这种情况下，参数缓冲区的[[id（n）]]属性限定符的行为与函数参数的[[texture（n）]]属性限定符的行为相同，其中n是数组的基本索引值。 但是，您不要调用MTLRenderCommandEncoder对象的setFragmentTexture：atIndex：方法来设置数组中的纹理。 相反，您调用MTLArgumentEncoder对象的setTexture：atIndex：方法，将数组中的纹理编码到参数缓冲区中，其中index对应于基本索引值n，加上数组中纹理的索引。
此示例中的参数缓冲区被声明为FragmentShaderArguments结构，这是它的定义：
typedef struct FragmentShaderArguments {
array<texture2d<float>, AAPLNumTextureArguments> exampleTextures [[ id(AAPLArgumentBufferIDExampleTextures) ]];
array<device float *, AAPLNumBufferArguments> exampleBuffers [[ id(AAPLArgumentBufferIDExampleBuffers) ]];
array<uint32_t, AAPLNumBufferArguments> exampleConstants [[ id(AAPLArgumentBufferIDExampleConstants) ]];
} FragmentShaderArguments;
此结构的每个元素都使用array<T, N>模板，该模板将元素定义为特定类型的数组，T和元素数量N。此参数缓冲区包含以下资源：
-
exampleTextures，一个包含32个2D纹理的数组，其基本索引值为0。 -
exampleBuffers，一个由32个浮点缓冲区组成的数组，其基本索引值为100。 -
exampleConstants，一个由32个uint32_t常量组成的数组，其基本索引值为200。
Encode Array Elements into an Argument Buffer - 将数组元素编码到参数缓冲区中
此示例通过匹配每个setTexture：atIndex：，setBuffer：offset：atIndex：和constantDataAtIndex：方法的索引参数调用元素的相应索引值（由参数缓冲区中的属性限定符[[id（n）]定义）将数组元素编码到参数缓冲区中 。
for(uint32_t i = 0; i < AAPLNumTextureArguments; i++)
{
[argumentEncoder setTexture:_texture[i]
atIndex:AAPLArgumentBufferIDExampleTextures+i];
}
for(uint32_t i = 0; i < AAPLNumBufferArguments; i++)
{
[argumentEncoder setBuffer:_dataBuffer[i]
offset:0
atIndex:AAPLArgumentBufferIDExampleBuffers+i];
uint32_t *elementCountAddress =
[argumentEncoder constantDataAtIndex:AAPLArgumentBufferIDExampleConstants+i];
*elementCountAddress = (uint32_t)_dataBuffer[i].length / 4;
}
Access Array Elements in an Argument Buffer - 访问参数缓冲区中的数组元素
在函数内，访问参数缓冲区中编码的数组元素与访问标准数组的元素相同。 在此示例中，exampleTextures，exampleBuffers和exampleConstants数组通过fragmentShader函数的fragmentShaderArgs参数进行访问。 使用[n]下标语法访问每个数组元素，其中n是数组中元素的索引。
for(uint32_t textureToSample = 0; textureToSample < AAPLNumBufferArguments; textureToSample++)
{
float4 textureValue = fragmentShaderArgs.exampleTextures[textureToSample].sample(textureSampler, in.texCoord);
color += textureValue;
}
fragmentShader函数包含if-else条件，该条件评估texCoord的x分量以确定片段所在的四边形的哪一侧。 如果片段位于四边形的左侧，则该函数对exampleTextures数组中的每个纹理进行采样，并添加采样值以确定最终输出颜色。
如果片段位于四边形的右侧，则该函数从exampleBuffers数组中读取一个值。 该函数使用texCoord的x组件来确定要读取的缓冲区，然后使用texCoord的y组件来确定缓冲区中的读取位置。 缓冲区中的值确定最终输出颜色。
// Use texCoord.x to select the buffer to read from
uint32_t bufferToRead = (in.texCoord.x-0.5)*2.0 * (AAPLNumBufferArguments-1);
// Retrieve the number of elements for the selected buffer from
// the array of constants in the argument buffer
uint32_t numElements = fragmentShaderArgs.exampleConstants[bufferToRead];
// Determine the index used to read from the buffer
uint32_t indexToRead = in.texCoord.y * numElements;
// Retrieve the buffer to read from by accessing the array of
// buffers in the argument buffer
device float* buffer = fragmentShaderArgs.exampleBuffers[bufferToRead];
// Read from the buffer and assign the value to the output color
color = buffer[indexToRead];
Combine Argument Buffers with Resource Heaps - 将参数缓冲区与资源堆组合在一起
片段函数通过参数缓冲区访问32个纹理和32个缓冲区，总共64个不同的资源。 如果每个资源的内存都是单独分配的，尽管存在于数组中，Metal需要验证64个独立资源的内存，然后才能使GPU访问这些资源。
相反，此示例从MTLHeap对象分配资源。 堆是单个内存区域，可以从中分配多个资源。 因此，示例可以通过调用useHeap：方法一次使堆的整个内存（包括堆内所有资源的内存）可供GPU访问。
该示例实现了一个loadResources方法，该方法将资源数据加载到临时MTLTexture和MTLBuffer对象中。 然后，该示例实现了一个createHeap方法，该方法计算将资源数据存储在堆中所需的总大小，并创建堆本身。
- (void) createHeap
{
MTLHeapDescriptor *heapDescriptor = [MTLHeapDescriptor new];
heapDescriptor.storageMode = MTLStorageModePrivate;
heapDescriptor.size = 0;
// Build a descriptor for each texture and calculate the size required to store all textures in the heap
for(uint32_t i = 0; i < AAPLNumTextureArguments; i++)
{
// Create a descriptor using the texture's properties
MTLTextureDescriptor *descriptor = [AAPLRenderer newDescriptorFromTexture:_texture[i]
storageMode:heapDescriptor.storageMode];
// Determine the size required for the heap for the given descriptor
MTLSizeAndAlign sizeAndAlign = [_device heapTextureSizeAndAlignWithDescriptor:descriptor];
// Align the size so that more resources will fit in the heap after this texture
sizeAndAlign.size += (sizeAndAlign.size & (sizeAndAlign.align - 1)) + sizeAndAlign.align;
// Accumulate the size required to store this texture in the heap
heapDescriptor.size += sizeAndAlign.size;
}
// Calculate the size required to store all buffers in the heap
for(uint32_t i = 0; i < AAPLNumBufferArguments; i++)
{
// Determine the size required for the heap for the given buffer size
MTLSizeAndAlign sizeAndAlign = [_device heapBufferSizeAndAlignWithLength:_dataBuffer[i].length
options:MTLResourceStorageModePrivate];
// Align the size so that more resources will fit in the heap after this buffer
sizeAndAlign.size += (sizeAndAlign.size & (sizeAndAlign.align - 1)) + sizeAndAlign.align;
// Accumulate the size required to store this buffer in the heap
heapDescriptor.size += sizeAndAlign.size;
}
// Create a heap large enough to store all resources
_heap = [_device newHeapWithDescriptor:heapDescriptor];
}
该示例实现了一个moveResourcesToHeap方法，该方法创建从堆分配的永久MTLTexture和MTLBuffer对象。 然后，该方法使用MTLBlitCommandEncoder将资源数据从临时对象复制到永久对象。
- (void)moveResourcesToHeap
{
// Create a command buffer and blit encoder to copy data from the existing resources to
// the new resources created from the heap
id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
commandBuffer.label = @"Heap Copy Command Buffer";
id <MTLBlitCommandEncoder> blitEncoder = commandBuffer.blitCommandEncoder;
// Create new textures from the heap and copy the contents of the existing textures to
// the new textures
for(uint32_t i = 0; i < AAPLNumTextureArguments; i++)
{
// Create a descriptor using the texture's properties
MTLTextureDescriptor *descriptor = [AAPLRenderer newDescriptorFromTexture:_texture[i]
storageMode:_heap.storageMode];
// Create a texture from the heap
id<MTLTexture> heapTexture = [_heap newTextureWithDescriptor:descriptor];
// Blit every slice of every level from the existing texture to the new texture
MTLRegion region = MTLRegionMake2D(0, 0, _texture[i].width, _texture[i].height);
for(NSUInteger level = 0; level < _texture[i].mipmapLevelCount; level++)
{
for(NSUInteger slice = 0; slice < _texture[i].arrayLength; slice++)
{
[blitEncoder copyFromTexture:_texture[i]
sourceSlice:slice
sourceLevel:level
sourceOrigin:region.origin
sourceSize:region.size
toTexture:heapTexture
destinationSlice:slice
destinationLevel:level
destinationOrigin:region.origin];
}
region.size.width /= 2;
region.size.height /= 2;
if(region.size.width == 0) region.size.width = 1;
if(region.size.height == 0) region.size.height = 1;
}
// Replace the existing texture with the new texture
_texture[i] = heapTexture;
}
// Create new buffers from the heap and copy the contents of existing buffers to the
// new buffers
for(uint32_t i = 0; i < AAPLNumBufferArguments; i++)
{
// Create a buffer from the heap
id<MTLBuffer> heapBuffer = [_heap newBufferWithLength:_dataBuffer[i].length
options:MTLResourceStorageModePrivate];
// Blit contents of the original buffer to the new buffer
[blitEncoder copyFromBuffer:_dataBuffer[i]
sourceOffset:0
toBuffer:heapBuffer
destinationOffset:0
size:heapBuffer.length];
// Replace the existing buffer with the new buffer
_dataBuffer[i] = heapBuffer;
}
[blitEncoder endEncoding];
[commandBuffer commit];
}
在使用这些资源之前，该示例不是为每个资源调用useResource：usage：方法一次，而是为整个堆调用useHeap：方法一次。
#if ENABLE_RESOURCE_HEAP
// Make a single `useHeap:` call for the entire heap, instead of one
// `useResource:usage:` call per texture and per buffer
[renderEncoder useHeap:_heap];
#else
for(uint32_t i = 0; i < AAPLNumTextureArguments; i++)
{
// Indicate to Metal that these textures will be accessed by the GPU and
// therefore must be mapped to the GPU's address space
[renderEncoder useResource:_texture[i] usage:MTLResourceUsageSample];
}
for(uint32_t i = 0; i < AAPLNumBufferArguments; i++)
{
// Indicate to Metal that these buffers will be accessed by the GPU and
// therefore must be mapped to the GPU's address space
[renderEncoder useResource:_dataBuffer[i] usage:MTLResourceUsageRead];
}
#endif
在此示例中，您学习了如何将参数缓冲区与资源数组和资源堆组合在一起。
后记
本篇主要讲述了带有数组和资源堆的参数缓冲区，感兴趣的给个赞或者关注~~~
