移动端图形API之管线

GPU 管线概述

GPU（图形处理单元）管线是一个高度优化的处理流程，专门设计用于高效地执行并行计算，尤其是在图形渲染和通用计算任务中。与 CPU 的通用计算能力不同，GPU 的架构和编程模型要求开发者遵循特定的约定和流程，以充分利用其并行处理能力。

1. 渲染管线

渲染管线是 GPU 管线的一个重要组成部分，主要用于将三维场景转换为二维图像。渲染管线通常包括以下几个阶段：

• 顶点处理（Vertex Processing）：

  • 在这一阶段，顶点着色器（Vertex Shader）对每个顶点进行处理，包括变换、光照计算等。
  • 结果是经过变换的顶点数据，通常包括位置、颜色、法线等信息。

• 图元装配（Primitive Assembly）：

  • 将处理后的顶点组合成图元（如三角形、线段等）。
  • 这一阶段负责确定如何将顶点连接在一起形成图形。

• 光栅化（Rasterization）：

  • 将图元转换为片段（Fragment），即屏幕上的像素。
  • 在这一阶段，GPU 计算哪些像素被图元覆盖，并生成相应的片段数据。

• 片段处理（Fragment Processing）：

  • 片段着色器（Fragment Shader）对每个片段进行处理，计算最终的颜色值、深度值等。
  • 这一阶段可能涉及纹理采样、光照计算等操作。

• 输出合并（Output Merging）：

  • 将片段的颜色值与帧缓冲中的现有值进行合并，决定最终的像素颜色。
  • 这一阶段通常涉及深度测试、模板测试等。

2. 计算管线

除了渲染管线，GPU 还支持通用计算管线（GPGPU），用于执行非图形计算任务。计算管线的设计允许开发者利用 GPU 的并行处理能力来加速各种计算密集型任务，如物理模拟、机器学习等。计算管线的主要特点包括：

• 并行计算：

  • GPU 可以同时处理大量数据，适合大规模并行计算任务。

• 计算着色器（Compute Shader）：

  • 计算着色器是一种特殊的着色器，允许开发者编写自定义的计算逻辑，处理数据并执行复杂的计算任务。

• 数据并行性：

  • 计算管线强调数据并行性，允许开发者在同一时间对多个数据元素进行相同的操作。

3. 编程模型与约定

由于 GPU 的架构与 CPU 有所不同，开发者在编写 GPU 程序时需要遵循特定的编程模型和约定：

• 数据并行性：设计程序时要考虑数据的并行处理，尽量减少数据依赖。
• 状态机：GPU 管线通常是一个状态机，开发者需要明确设置状态（如着色器、纹理、缓冲区等）。
• API 调用：使用图形 API（如 OpenGL、Vulkan、DirectX 等）进行管线的配置和数据传输，遵循 API 的调用约定。

总结

GPU 管线是一个复杂而高效的处理流程，专为并行计算和图形渲染而设计。理解 GPU 管线的各个阶段及其约定，对于开发高效的图形应用和利用 GPU 进行通用计算至关重要。通过遵循这些约定，开发者可以充分发挥 GPU 的性能优势，实现高效的图形渲染和计算任务。

GPU 管线的整体结构

GPU 管线是一个由多个处理节点按时序连接而成的数据处理系统。数据在管线中经过一系列处理后，最终输出另一种数据形式。对于图形管线，输出通常是写入到帧缓冲（frame buffer），而对于计算管线，输出则是写入到图像（image）或缓冲区（buffer）。管线的整体结构可以分为以下四个主要部分：

1. 可编程的处理模块

• 定义：可编程的处理模块是指开发者可以自定义的部分，通常是通过编写着色器（shader）来实现的。这些着色器可以是顶点着色器、片段着色器、计算着色器等。
• 功能：开发者可以根据需要编写运行代码，以实现特定的图形效果或计算任务。设置这些着色器到管线中是使用 GPU 的关键步骤。

2. 固定的处理模块

• 定义：固定的处理模块是指硬件固化的部分，开发者无法改变其逻辑。
• 功能：虽然逻辑不可更改，但驱动程序通常会暴露许多开关和参数，允许开发者调控这些模块的行为。例如，深度测试、混合模式、剔除模式等都属于这一类。

3. 资源挂点

• 定义：在现代 GPU 管线中，资源的访问方式与 CPU 程序不同。GPU 通常不能通过索引指针地址的方式直接访问资源，而是通过固定的有限个数的资源挂接点（resource binding points）来访问。
• 功能：任何想要被管线访问的资源必须先绑定到某个资源挂点上。这种设计使得资源管理更加高效和安全。

4. 资源对象

• 定义：资源对象是需要绑定到资源挂点上的具体数据结构，例如纹理、缓冲区、渲染目标等。
• 功能：虽然资源挂点的数量有限，但资源对象的创建数量没有限制。开发者可以创建多个资源对象，并在需要时切换它们的绑定。

操作 GPU 管线的四个步骤

为了通过 API 操作 GPU 管线，开发者通常需要执行以下四个步骤：

1. 设置管线的 Shader

• 实现：使用图形 API（如 OpenGL、Vulkan、DirectX 等）编写和编译着色器代码，并将其设置到管线中。这通常涉及创建着色器对象、编译着色器、链接程序等步骤。

2. 调控固定管线的开关和参数

• 实现：通过 API 调用设置固定处理模块的状态和参数。例如，启用或禁用深度测试、设置混合模式、调整视口等。这些设置通常通过特定的 API 函数进行。

3. 创建资源

• 实现：使用 API 创建需要的资源对象，如纹理、缓冲区等。这通常涉及分配内存、设置格式和尺寸等步骤。

4. 绑定资源

• 实现：将创建的资源对象绑定到相应的资源挂点上。这通常通过 API 提供的绑定函数实现，例如在 OpenGL 中使用 glBindTexture 或在 Vulkan 中使用 vkBindDescriptorSets。

总结

GPU 管线的整体结构由可编程的处理模块、固定的处理模块、资源挂点和资源对象四个部分组成。通过理解这些组成部分及其功能，开发者可以有效地利用图形 API 操作 GPU 管线，完成图形渲染和计算任务。每个步骤的实现都需要遵循特定的 API 调用约定，以确保管线的正确配置和高效运行。

管线的 Shader 设置

在 GPU 管线中，Shader 是可编程的处理模块，负责执行特定的计算任务。Shader 通常分为多个类型，例如顶点着色器、片段着色器、几何着色器等。整个管线由多个 Shader 组成，这些 Shader 的集合被称为一个 Program。以下是 Shader 和 Program 的创建过程，以及如何将其与管线对象结合。

5.2.1 从 Shader、Program 到 Pipeline

1. Shader 的创建与编译

   • 定义：每个单独的 Shader 被称为一个 Shader。Shader 通常是用高层次的着色语言（如 GLSL、HLSL、SPIR-V 等）编写的。
   • 编译过程：开发者从源码创建 Shader，这个过程称为 Shader 的编译。编译的结果通常是一个中间文件，表示为一种中间表示（IR），该文件不能直接执行。
   • 链接：为了生成最终可执行的机器特定的二进制文件（即 Program），需要将管线中所有的 Shader 进行链接。链接过程将各个 Shader 的输入和输出连接起来，形成一个完整的执行单元。

2. Program 的创建

   • 定义：Program 是由多个 Shader 组成的集合，代表了一个完整的渲染或计算管线。
   • 创建过程：在创建 Program 时，开发者需要将编译后的 Shader 传递给 API，进行链接以生成最终的可执行代码。这个过程通常涉及 API 调用，如 OpenGL 中的 glLinkProgram。

3. Pipeline 对象的创建

   • Vulkan 和 Metal 的特性：在 Vulkan 和 Metal 等现代图形 API 中，Program 的创建通常需要知道其他固定管线参数。因此，在这些 API 中，创建的是整个 Pipeline 对象，而不仅仅是 Program。
   • Pipeline 对象：Pipeline 对象包含了所有必要的状态和设置，包括 Shader、渲染状态、输入布局、光栅化状态等。创建 Pipeline 对象的过程通常比创建 Program 更复杂，因为它需要考虑更多的固定参数。

4. 离线编译与二进制文件

   • 性能优化：由于 Program 的创建是一个耗时的操作，一些 API 提供了直接从离线编译好的二进制文件创建 Program 的功能。这种方式可以显著减少运行时的编译和链接时间。
   • 机器相关性：需要注意的是，Program 通常是与特定机器架构相关的机器代码，因此生成的二进制文件不能跨机器使用。每台机器都需要在其特定环境中生成二进制文件，以便在下次使用时复用。

总结

在 GPU 管线中，Shader 是可编程的处理模块，多个 Shader 组合成一个 Program。Shader 的创建和编译是生成可执行代码的第一步，而 Program 的创建则是将所有 Shader 链接在一起的过程。在 Vulkan 和 Metal 等现代 API 中，创建的是整个 Pipeline 对象，包含了所有必要的状态和设置。为了提高性能，API 还支持从离线编译的二进制文件直接创建 Program，但需要注意这些二进制文件的机器相关性。理解这些概念对于有效地设置和优化 GPU 管线至关重要。

Shader 的创建和编译

Shader 是 GPU 上的一种对象，在使用之前需要先创建并编译。不同的图形 API 对 Shader 的创建和编译有不同的流程。以下是 OpenGL ES、Vulkan 和 Metal 中 Shader 的创建和编译过程的详细说明。

1. OpenGL ES 中的 Shader 创建与编译

在 OpenGL ES 中，Shader 的创建和编译过程如下：

• 创建 Shader 对象：

  GLuint shader = glCreateShader(type);
  

  这里的 type 可以是 GL_VERTEX_SHADER、GL_FRAGMENT_SHADER 等，表示 Shader 的类型。

• 装载 Shader 源代码：

  glShaderSource(shader, 1, &source, NULL);
  

  source 是一个指向 Shader 源代码的字符串指针，第二个参数是源代码的数量。

• 编译 Shader：

  glCompileShader(shader);
  

  编译后，可以通过 glGetShaderiv 和 glGetShaderInfoLog 来检查编译是否成功，并获取编译日志。

2. Vulkan 中的 Shader 创建与编译

在 Vulkan 中，Shader 的创建和编译过程相对复杂，通常涉及以下步骤：

• 创建 Shader Module：

  VkShaderModule shaderModule;
  VkShaderModuleCreateInfo createInfo = {};
  createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
  createInfo.codeSize = sizeof(shaderCode);
  createInfo.pCode = reinterpret_cast<const uint32_t*>(shaderCode);
  
  vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule);
  

  这里的 shaderCode 是已经编译好的 Shader 代码（通常是 SPIR-V 格式），device 是 Vulkan 设备的句柄。

• 使用 Shader Module：
  创建 Shader Module 后，可以在管线创建时将其绑定到相应的管线阶段。

3. Metal 中的 Shader 创建与编译

在 Metal 中，Shader 被称为 MtlFunction，并且通常会将一个或多个 MtlFunction 打包成一个 MtlLibrary。创建和编译的过程如下：

• 创建 MtlLibrary：

  NSError *error = nil;
  id<MTLLibrary> library = [device newLibraryWithSource:source options:nil error:&error];
  

  这里的 source 是包含一个或多个 Shader 源代码的字符串。

• 从 MtlLibrary 创建 MtlFunction：

  id<MTLFunction> function = [library newFunctionWithName:@"functionName"];
  

  functionName 是 Shader 的名称。

• 加载已编译的 MTLLibrary：
  Metal 还允许直接加载已经离线编译好的二进制 MTLLibrary 文件：

  NSData *data = [NSData dataWithContentsOfFile:@"path/to/library.metallib"];
  id<MTLLibrary> library = [device newLibraryWithData:data error:&error];
  

总结

在不同的图形 API 中，Shader 的创建和编译过程有所不同：

• OpenGL ES：通过 glCreateShader、glShaderSource 和 glCompileShader 来创建和编译 Shader。
• Vulkan：使用 vkCreateShaderModule 创建 Shader Module，Shader 代码通常是 SPIR-V 格式。
• Metal：通过 newLibraryWithSource 创建 MtlLibrary，并从中创建 MtlFunction，支持从二进制文件加载已编译的库。

Metal 在 Shader 编译层面提供了从二进制加载的方案，而 Vulkan 和 OpenGL ES 主要在 Program/Pipeline 层面提供了二进制机制。Metal 的 Shader 创建过程相对复杂，但也提供了更灵活的选项。

创建 Program 或 Pipeline

在图形编程中，Shader 是渲染管线的核心部分，而 Program 或 Pipeline 则是将 Shader 与其他渲染状态结合在一起的结构。不同的图形 API 对于创建 Program 或 Pipeline 的流程有所不同。以下是 OpenGL ES、Vulkan 和 Metal 中创建 Program 或 Pipeline 的详细步骤。

1. OpenGL ES 中的 Program 创建

在 OpenGL ES 中，创建 Program 的过程如下：

• 创建 Program 对象：

  GLuint program = glCreateProgram();
  

• 附加 Shader：

  glAttachShader(program, vertexShader);
  glAttachShader(program, fragmentShader);
  

  这里的 vertexShader 和 fragmentShader 是之前创建并编译的 Shader 对象。

• 链接 Program：

  glLinkProgram(program);
  

  链接后，可以使用 glGetProgramiv 和 glGetProgramInfoLog 来检查链接是否成功，并获取链接日志。

• 使用 Program：

  glUseProgram(program);
  

2. Vulkan 中的 Pipeline 创建

在 Vulkan 中，Pipeline 的创建过程相对复杂，需要设置多个固定管线参数。以下是创建 Graphics Pipeline 的步骤：

• 定义 VkGraphicsPipelineCreateInfo 结构：

  VkGraphicsPipelineCreateInfo pipelineInfo = {};
  pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
  pipelineInfo.stageCount = 2; // 例如，顶点和片段着色器
  VkPipelineShaderStageCreateInfo shaderStages[2];
  
  // 设置顶点着色器
  shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
  shaderStages[0].module = vertexShaderModule; // VkShaderModule
  shaderStages[0].pName = "main"; // Shader 的入口函数名
  
  // 设置片段着色器
  shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
  shaderStages[1].module = fragmentShaderModule; // VkShaderModule
  shaderStages[1].pName = "main"; // Shader 的入口函数名
  
  pipelineInfo.pStages = shaderStages;
  
  // 其他固定管线参数的设置
  pipelineInfo.pVertexInputState = &vertexInputInfo; // 顶点输入状态
  pipelineInfo.pInputAssemblyState = &inputAssembly; // 输入装配状态
  pipelineInfo.pViewportState = &viewportState; // 视口状态
  pipelineInfo.pRasterizationState = &rasterizer; // 光栅化状态
  pipelineInfo.pMultisampleState = &multisampling; // 多重采样状态
  pipelineInfo.pColorBlendState = &colorBlending; // 颜色混合状态
  pipelineInfo.layout = pipelineLayout; // 管线布局
  pipelineInfo.renderPass = renderPass; // 渲染通道
  pipelineInfo.subpass = 0; // 子通道索引
  
  // 创建 Pipeline
  VkPipeline graphicsPipeline;
  vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline);
  

3. Metal 中的 Pipeline 创建

在 Metal 中，Pipeline 的创建过程也相对简单，使用 MTLRenderPipelineDescriptor 来描述 Pipeline 的状态。以下是创建 Render Pipeline 的步骤：

• 创建 MTLRenderPipelineDescriptor：

  MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
  pipelineDescriptor.vertexFunction = vertexFunction; // 设置顶点函数
  pipelineDescriptor.fragmentFunction = fragmentFunction; // 设置片段函数
  pipelineDescriptor.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm; // 设置颜色附件格式
  

• 创建 Render Pipeline State：

  NSError *error = nil;
  id<MTLRenderPipelineState> renderPipelineState = [device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:&error];
  if (error) {
      NSLog(@"Error occurred when creating render pipeline state: %@", error);
  }
  

• 创建 Compute Pipeline（如果需要）：

  MTLComputePipelineDescriptor *computePipelineDescriptor = [[MTLComputePipelineDescriptor alloc] init];
  computePipelineDescriptor.computeFunction = computeFunction; // 设置计算函数
  
  id<MTLComputePipelineState> computePipelineState = [device newComputePipelineStateWithDescriptor:computePipelineDescriptor error:&error];
  if (error) {
      NSLog(@"Error occurred when creating compute pipeline state: %@", error);
  }
  

总结

在不同的图形 API 中，创建 Program 或 Pipeline 的过程有所不同：

• OpenGL ES：通过 glCreateProgram、glAttachShader 和 glLinkProgram 来创建和链接 Program。
• Vulkan：使用 vkCreateGraphicsPipelines 创建 Pipeline，需要设置多个固定管线参数和 Shader 模块。
• Metal：通过 MTLRenderPipelineDescriptor 创建 Render Pipeline，支持设置顶点和片段函数。

Vulkan 和 Metal 的 Pipeline 创建过程相对复杂，需要考虑更多的固定管线状态，而 OpenGL ES 的过程则相对简单。理解这些流程对于有效地设置和优化图形管线至关重要。

Program Binary

在现代图形 API 中，使用预编译的程序二进制文件（Program Binary）可以显著提高性能，因为这避免了在运行时进行 Shader 编译和链接的开销。以下是如何在 OpenGL ES、Vulkan 和 Metal 中处理 Program Binary 的详细说明。

1. OpenGL ES 中的 Program Binary

在 OpenGL ES 中，可以通过以下步骤获取和使用 Program Binary：

• 获取 Program Binary：
  使用 glGetProgramBinary 函数获取当前 Program 的二进制数据。

  GLint binaryLength;
  glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
  GLvoid* binary = malloc(binaryLength);
  GLenum binaryFormat;
  glGetProgramBinary(program, binaryLength, &binaryLength, &binaryFormat, binary);
  

• 保存 Binary：
  将获取的二进制数据保存到文件或其他存储介质中，以便后续使用。

• 加载 Program Binary：
  使用 glProgramBinary 函数加载之前保存的二进制数据。

  glProgramBinary(program, binaryFormat, binary, binaryLength);
  

2. Vulkan 中的 Pipeline Cache

在 Vulkan 中，Pipeline Cache 机制允许保存和重用整个 Pipeline 的二进制数据。以下是相关步骤：

• 创建 Pipeline Cache：
  使用 vkCreatePipelineCache 创建一个 Pipeline Cache 对象。

  VkPipelineCache pipelineCache;
  VkPipelineCacheCreateInfo cacheInfo = {};
  cacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
  vkCreatePipelineCache(device, &cacheInfo, nullptr, &pipelineCache);
  

• 创建 Graphics Pipeline：
  在创建 Pipeline 时，将 Pipeline Cache 传入。

  VkGraphicsPipelineCreateInfo pipelineInfo = {};
  // 设置 pipelineInfo 的其他参数
  vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineInfo, nullptr, &graphicsPipeline);
  

• 获取 Pipeline Cache 数据：
  使用 vkGetPipelineCacheData 获取 Pipeline Cache 中的二进制数据，并保存。

  size_t dataSize;
  vkGetPipelineCacheData(device, pipelineCache, &dataSize, nullptr);
  std::vector<uint8_t> cacheData(dataSize);
  vkGetPipelineCacheData(device, pipelineCache, &dataSize, cacheData.data());
  

• 复用 Pipeline Cache：
  创建新的 Pipeline Cache 时，传入之前保存的二进制数据。

  VkPipelineCacheCreateInfo cacheInfo = {};
  cacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
  cacheInfo.initialDataSize = previousCacheDataSize; // 之前的二进制数据大小
  cacheInfo.pInitialData = previousCacheData; // 之前的二进制数据
  vkCreatePipelineCache(device, &cacheInfo, nullptr, &newPipelineCache);
  

3. Metal 中的 Binary Archive

在 Metal 中，Binary Archive 是一种新的特性（iOS 14 及以上），允许保存和复用整个 Pipeline。以下是相关步骤：

• 创建 Binary Archive：
  使用 newBinaryArchiveWithDescriptor 创建一个 Binary Archive。

  MTLBinaryArchive *binaryArchive = [device newBinaryArchiveWithDescriptor:archiveDescriptor];
  

• 添加 Render Pipeline 到 Archive：
  使用 addRenderPipelineFunctionsWithDescriptor 将创建好的 Pipeline 添加到 Archive 中。

  [binaryArchive addRenderPipelineFunctionsWithDescriptor:pipelineDescriptor];
  

• 序列化 Binary Archive：
  使用 serializeToURL 将 Binary Archive 写出到文件。

  [binaryArchive serializeToURL:archiveURL error:&error];
  

• 复用 Binary Archive：
  创建新的 Binary Archive 时，传入之前保存的二进制文件路径。

  MTLBinaryArchive *loadedArchive = [device newBinaryArchiveWithDescriptor:archiveDescriptor];
  [loadedArchive loadFromURL:archiveURL error:&error];
  

• 创建 Pipeline 时使用 Binary Archive：
  在创建 Pipeline 时，将 Binary Archive 传入。

  pipelineDescriptor.binaryArchives = @[loadedArchive];
  

设置 Program 或 Pipeline

在创建好 Program 或 Pipeline 后，需要将其设置为当前的渲染管线。

1. OpenGL ES

使用 glUseProgram 来设置当前的 Program。

glUseProgram(program);

2. Vulkan

使用 vkCmdBindPipeline 将 Pipeline 绑定到命令缓冲区。

vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);

3. Metal

使用 setRenderPipelineState 方法将 Render Pipeline State 设置到 Render Command Encoder。

[renderCommandEncoder setRenderPipelineState:renderPipelineState];

总结

使用 Program Binary 或 Pipeline Cache 可以显著提高图形应用的性能，避免在运行时进行 Shader 编译和链接的开销。不同的图形 API 提供了不同的机制来支持这一特性：

• OpenGL ES：使用 glGetProgramBinary 和 glProgramBinary。
• Vulkan：使用 Pipeline Cache 和相关的 API。
• Metal：使用 Binary Archive 机制。

理解这些机制并合理使用，可以有效提升图形应用的启动速度和运行效率。

Metal 中的 Dynamic Library

在 Metal 中，Dynamic Library 机制允许开发者将共享的 Shader 代码抽离出来，避免在每次编译时重复编译相同的代码。这一特性自 iOS 15 及以上版本开始支持，能够显著提高 Shader 的编译效率和 Pipeline 的创建速度。

1. Dynamic Library 的创建

要使用 Dynamic Library，首先需要将共享的 Shader 代码打包到一个单独的 Metal Library 中。以下是创建 Dynamic Library 的步骤：

• 创建 Metal Library：
  将共享的 Shader 代码编译为一个 Metal Library（.metallib 文件）。

• 加载 Dynamic Library：
  使用 MTLDevice 的 newDynamicLibrary 方法从这个 Metal Library 创建 MTLDynamicLibrary 对象。

  NSError *error = nil;
  NSURL *libraryURL = [NSURL fileURLWithPath:@"path/to/your/library.metallib"];
  MTLDynamicLibrary *dynamicLibrary = [device newDynamicLibraryWithURL:libraryURL error:&error];
  

注意：MTLDynamicLibrary 是机器特定的二进制代码，不能跨机器使用。

2. 在 Pipeline 中使用 Dynamic Library

在创建 Pipeline 时，可以将 MTLDynamicLibrary 添加到 Pipeline Descriptor 中，以便动态加载这些共享的 Shader 代码。

• 设置 Pipeline Descriptor：
  在创建 MTLRenderPipelineDescriptor 时，将 fragmentPreloadedLibraries 属性设置为包含 MTLDynamicLibrary 的数组。

  MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
  pipelineDescriptor.fragmentPreloadedLibraries = @[dynamicLibrary];
  

• 创建 Render Pipeline：
  使用配置好的 Pipeline Descriptor 创建 Render Pipeline。

  NSError *error = nil;
  id<MTLRenderPipelineState> renderPipelineState = [device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:&error];
  

3. Binary Library、Binary Archive 和 Dynamic Library 的区别

在 Metal 中，虽然 Binary Library、Binary Archive 和 Dynamic Library 都与 Shader 和 Pipeline 的编译和链接相关，但它们的作用和使用场景有所不同：

• Binary Library：

  • 是编译后的 Shader 代码的集合，通常是一个 .metallib 文件。
  • 可以包含多个 Shader 函数，供应用程序在运行时使用。

• Binary Archive：

  • 是一种新的特性，允许将多个 Pipeline 的状态和相关的 Shader 代码打包在一起。
  • 适用于需要在多个 Pipeline 之间共享状态和代码的场景。

• Dynamic Library：

  • 是一种动态加载的 Shader 代码库，允许在运行时加载和使用共享的 Shader 代码。
  • 适用于需要频繁复用 Shader 代码的场景，能够减少编译时间。

4. 直观表示

为了更好地理解这三者的关系，可以用一张图来表示它们的作用和使用场景：

+-------------------+
|   Binary Library   |
|  (Compiled Shaders)|
+-------------------+
          |
          |  (Used in)
          v
+-------------------+
|   Binary Archive   |
| (Multiple Pipelines)|
+-------------------+
          |
          |  (Dynamic Loading)
          v
+-------------------+
|   Dynamic Library   |
| (Shared Shader Code)|
+-------------------+

总结

Metal 的 Dynamic Library 机制为 Shader 代码的复用提供了灵活的解决方案，能够有效减少编译时间并提高 Pipeline 创建的效率。通过合理使用 Binary Library、Binary Archive 和 Dynamic Library，开发者可以优化 Metal 应用的性能和可维护性。