kc3-lang/angle/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h

• Show log

  Commit

• Hash : 9601a548
  Author :
  Date : 2019-11-23T23:44:52
  

  Vulkan: implement external semaphore barriers
  
  glWaitSemaphoreEXT and glSignalSemaphoreEXT functions optionally request
  buffer and image barriers to be performed by the implementation.
  
  If any barriers are present, a single global memory barrier is inserted
  to take care of memory accesses.
  
  In both functions, buffer and image memory barriers are used to perform
  queue ownership transfers to ANGLE's queue (glWaitSemaphoreEXT) or the
  EXTERNAL queue (glSignalSemaphoreEXT).
  
  In glWaitSemaphoreEXT, the given layouts are information regarding how
  the external entity (the caller) has modified the images' layouts, and
  is used to update ANGLE's internal state tracking.
  
  Bug: angleproject:3289
  Bug: 1026673
  Change-Id: Ic478a8813df727c89413c8ae2adf42b5c1d06069
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1933016
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Michael Spang <spang@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h

• //
  // Copyright 2019 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // SecondaryCommandBuffer:
  //    Lightweight, CPU-Side command buffers used to hold command state until
  //    it has to be submitted to GPU.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_SECONDARYCOMMANDBUFFERVK_H_
  #define LIBANGLE_RENDERER_VULKAN_SECONDARYCOMMANDBUFFERVK_H_
  
  #include <vulkan/vulkan.h>
  
  #include "common/PoolAlloc.h"
  #include "libANGLE/renderer/vulkan/vk_wrapper.h"
  
  namespace rx
  {
  
  namespace vk
  {
  
  namespace priv
  {
  
  enum class CommandID : uint16_t
  {
      // Invalid cmd used to mark end of sequence of commands
      Invalid = 0,
      BeginQuery,
      BindComputePipeline,
      BindDescriptorSets,
      BindGraphicsPipeline,
      BindIndexBuffer,
      BindVertexBuffers,
      BlitImage,
      BufferBarrier,
      ClearAttachments,
      ClearColorImage,
      ClearDepthStencilImage,
      CopyBuffer,
      CopyBufferToImage,
      CopyImage,
      CopyImageToBuffer,
      Dispatch,
      DispatchIndirect,
      Draw,
      DrawIndexed,
      DrawIndexedBaseVertex,
      DrawIndexedInstanced,
      DrawIndexedInstancedBaseVertex,
      DrawIndexedInstancedBaseVertexBaseInstance,
      DrawInstanced,
      DrawInstancedBaseInstance,
      DrawIndirect,
      DrawIndexedIndirect,
      EndQuery,
      ExecutionBarrier,
      FillBuffer,
      ImageBarrier,
      MemoryBarrier,
      PipelineBarrier,
      PushConstants,
      ResetEvent,
      ResetQueryPool,
      ResolveImage,
      SetEvent,
      WaitEvents,
      WriteTimestamp,
  };
  
  #define VERIFY_4_BYTE_ALIGNMENT(StructName) \
      static_assert((sizeof(StructName) % 4) == 0, "Check StructName alignment");
  
  // Structs to encapsulate parameters for different commands
  // This makes it easy to know the size of params & to copy params
  // TODO: Could optimize the size of some of these structs through bit-packing
  //  and customizing sizing based on limited parameter sets used by ANGLE
  struct BindPipelineParams
  {
      VkPipeline pipeline;
  };
  VERIFY_4_BYTE_ALIGNMENT(BindPipelineParams)
  
  struct BindDescriptorSetParams
  {
      VkPipelineLayout layout;
      VkPipelineBindPoint pipelineBindPoint;
      uint32_t firstSet;
      uint32_t descriptorSetCount;
      uint32_t dynamicOffsetCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(BindDescriptorSetParams)
  
  struct BindIndexBufferParams
  {
      VkBuffer buffer;
      VkDeviceSize offset;
      VkIndexType indexType;
  };
  VERIFY_4_BYTE_ALIGNMENT(BindIndexBufferParams)
  
  struct BindVertexBuffersParams
  {
      // ANGLE always has firstBinding of 0 so not storing that currently
      uint32_t bindingCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(BindVertexBuffersParams)
  
  struct BlitImageParams
  {
      VkImage srcImage;
      VkImage dstImage;
      VkFilter filter;
      VkImageBlit region;
  };
  VERIFY_4_BYTE_ALIGNMENT(BlitImageParams)
  
  struct CopyBufferParams
  {
      VkBuffer srcBuffer;
      VkBuffer destBuffer;
      uint32_t regionCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(CopyBufferParams)
  
  struct CopyBufferToImageParams
  {
      VkBuffer srcBuffer;
      VkImage dstImage;
      VkImageLayout dstImageLayout;
      VkBufferImageCopy region;
  };
  VERIFY_4_BYTE_ALIGNMENT(CopyBufferToImageParams)
  
  struct CopyImageParams
  {
      VkImage srcImage;
      VkImageLayout srcImageLayout;
      VkImage dstImage;
      VkImageLayout dstImageLayout;
      VkImageCopy region;
  };
  VERIFY_4_BYTE_ALIGNMENT(CopyImageParams)
  
  struct CopyImageToBufferParams
  {
      VkImage srcImage;
      VkImageLayout srcImageLayout;
      VkBuffer dstBuffer;
      VkBufferImageCopy region;
  };
  VERIFY_4_BYTE_ALIGNMENT(CopyImageToBufferParams)
  
  struct ClearAttachmentsParams
  {
      uint32_t attachmentCount;
      VkClearRect rect;
  };
  VERIFY_4_BYTE_ALIGNMENT(ClearAttachmentsParams)
  
  struct ClearColorImageParams
  {
      VkImage image;
      VkImageLayout imageLayout;
      VkClearColorValue color;
      VkImageSubresourceRange range;
  };
  VERIFY_4_BYTE_ALIGNMENT(ClearColorImageParams)
  
  struct ClearDepthStencilImageParams
  {
      VkImage image;
      VkImageLayout imageLayout;
      VkClearDepthStencilValue depthStencil;
      VkImageSubresourceRange range;
  };
  VERIFY_4_BYTE_ALIGNMENT(ClearDepthStencilImageParams)
  
  struct PushConstantsParams
  {
      VkPipelineLayout layout;
      VkShaderStageFlags flag;
      uint32_t offset;
      uint32_t size;
  };
  VERIFY_4_BYTE_ALIGNMENT(PushConstantsParams)
  
  struct DrawParams
  {
      uint32_t vertexCount;
      uint32_t firstVertex;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawParams)
  
  struct DrawInstancedParams
  {
      uint32_t vertexCount;
      uint32_t instanceCount;
      uint32_t firstVertex;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawInstancedParams)
  
  struct DrawInstancedBaseInstanceParams
  {
      uint32_t vertexCount;
      uint32_t instanceCount;
      uint32_t firstVertex;
      uint32_t firstInstance;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawInstancedBaseInstanceParams)
  
  struct DrawIndexedParams
  {
      uint32_t indexCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedParams)
  
  struct DrawIndexedBaseVertexParams
  {
      uint32_t indexCount;
      uint32_t vertexOffset;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedBaseVertexParams)
  
  struct DrawIndexedInstancedParams
  {
      uint32_t indexCount;
      uint32_t instanceCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedInstancedParams)
  
  struct DrawIndexedInstancedBaseVertexParams
  {
      uint32_t indexCount;
      uint32_t instanceCount;
      uint32_t vertexOffset;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedInstancedBaseVertexParams)
  
  struct DrawIndexedInstancedBaseVertexBaseInstanceParams
  {
      uint32_t indexCount;
      uint32_t instanceCount;
      uint32_t firstIndex;
      int32_t vertexOffset;
      uint32_t firstInstance;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedInstancedBaseVertexBaseInstanceParams)
  
  struct DrawIndexedIndirectParams
  {
      VkBuffer buffer;
      VkDeviceSize offset;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndexedIndirectParams)
  
  struct DispatchParams
  {
      uint32_t groupCountX;
      uint32_t groupCountY;
      uint32_t groupCountZ;
  };
  VERIFY_4_BYTE_ALIGNMENT(DispatchParams)
  
  struct DrawIndirectParams
  {
      VkBuffer buffer;
      VkDeviceSize offset;
  };
  VERIFY_4_BYTE_ALIGNMENT(DrawIndirectParams)
  
  struct DispatchIndirectParams
  {
      VkBuffer buffer;
      VkDeviceSize offset;
  };
  VERIFY_4_BYTE_ALIGNMENT(DispatchIndirectParams)
  
  struct FillBufferParams
  {
      VkBuffer dstBuffer;
      VkDeviceSize dstOffset;
      VkDeviceSize size;
      uint32_t data;
  };
  VERIFY_4_BYTE_ALIGNMENT(FillBufferParams)
  
  struct MemoryBarrierParams
  {
      VkPipelineStageFlags srcStageMask;
      VkPipelineStageFlags dstStageMask;
      VkMemoryBarrier memoryBarrier;
  };
  VERIFY_4_BYTE_ALIGNMENT(MemoryBarrierParams)
  
  struct PipelineBarrierParams
  {
      VkPipelineStageFlags srcStageMask;
      VkPipelineStageFlags dstStageMask;
      VkDependencyFlags dependencyFlags;
      uint32_t memoryBarrierCount;
      uint32_t bufferMemoryBarrierCount;
      uint32_t imageMemoryBarrierCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(PipelineBarrierParams)
  
  struct ExecutionBarrierParams
  {
      VkPipelineStageFlags stageMask;
  };
  VERIFY_4_BYTE_ALIGNMENT(ExecutionBarrierParams)
  
  struct BufferBarrierParams
  {
      VkPipelineStageFlags srcStageMask;
      VkPipelineStageFlags dstStageMask;
      VkBufferMemoryBarrier bufferMemoryBarrier;
  };
  VERIFY_4_BYTE_ALIGNMENT(BufferBarrierParams)
  
  struct ImageBarrierParams
  {
      VkPipelineStageFlags srcStageMask;
      VkPipelineStageFlags dstStageMask;
      VkImageMemoryBarrier imageMemoryBarrier;
  };
  VERIFY_4_BYTE_ALIGNMENT(ImageBarrierParams)
  
  struct SetEventParams
  {
      VkEvent event;
      VkPipelineStageFlags stageMask;
  };
  VERIFY_4_BYTE_ALIGNMENT(SetEventParams)
  
  struct ResetEventParams
  {
      VkEvent event;
      VkPipelineStageFlags stageMask;
  };
  VERIFY_4_BYTE_ALIGNMENT(ResetEventParams)
  
  struct WaitEventsParams
  {
      uint32_t eventCount;
      VkPipelineStageFlags srcStageMask;
      VkPipelineStageFlags dstStageMask;
      uint32_t memoryBarrierCount;
      uint32_t bufferMemoryBarrierCount;
      uint32_t imageMemoryBarrierCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(WaitEventsParams)
  
  struct ResetQueryPoolParams
  {
      VkQueryPool queryPool;
      uint32_t firstQuery;
      uint32_t queryCount;
  };
  VERIFY_4_BYTE_ALIGNMENT(ResetQueryPoolParams)
  
  struct ResolveImageParams
  {
      VkImage srcImage;
      VkImage dstImage;
      VkImageResolve region;
  };
  VERIFY_4_BYTE_ALIGNMENT(ResolveImageParams)
  
  struct BeginQueryParams
  {
      VkQueryPool queryPool;
      uint32_t query;
      VkQueryControlFlags flags;
  };
  VERIFY_4_BYTE_ALIGNMENT(BeginQueryParams)
  
  struct EndQueryParams
  {
      VkQueryPool queryPool;
      uint32_t query;
  };
  VERIFY_4_BYTE_ALIGNMENT(EndQueryParams)
  
  struct WriteTimestampParams
  {
      VkPipelineStageFlagBits pipelineStage;
      VkQueryPool queryPool;
      uint32_t query;
  };
  VERIFY_4_BYTE_ALIGNMENT(WriteTimestampParams)
  
  // Header for every cmd in custom cmd buffer
  struct CommandHeader
  {
      CommandID id;
      uint16_t size;
  };
  
  static_assert(sizeof(CommandHeader) == 4, "Check CommandHeader size");
  
  template <typename DestT, typename T>
  ANGLE_INLINE DestT *Offset(T *ptr, size_t bytes)
  {
      return reinterpret_cast<DestT *>((reinterpret_cast<uint8_t *>(ptr) + bytes));
  }
  
  template <typename DestT, typename T>
  ANGLE_INLINE const DestT *Offset(const T *ptr, size_t bytes)
  {
      return reinterpret_cast<const DestT *>((reinterpret_cast<const uint8_t *>(ptr) + bytes));
  }
  
  class SecondaryCommandBuffer final : angle::NonCopyable
  {
    public:
      SecondaryCommandBuffer();
      ~SecondaryCommandBuffer();
  
      static bool SupportsQueries(const VkPhysicalDeviceFeatures &features) { return true; }
  
      // SecondaryCommandBuffer replays its commands inline when executed on the primary command
      // buffer.
      static constexpr bool ExecutesInline() { return true; }
  
      // Add commands
      void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
  
      void bindComputePipeline(const Pipeline &pipeline);
  
      void bindDescriptorSets(const PipelineLayout &layout,
                              VkPipelineBindPoint pipelineBindPoint,
                              uint32_t firstSet,
                              uint32_t descriptorSetCount,
                              const VkDescriptorSet *descriptorSets,
                              uint32_t dynamicOffsetCount,
                              const uint32_t *dynamicOffsets);
  
      void bindGraphicsPipeline(const Pipeline &pipeline);
  
      void bindIndexBuffer(const Buffer &buffer, VkDeviceSize offset, VkIndexType indexType);
  
      void bindVertexBuffers(uint32_t firstBinding,
                             uint32_t bindingCount,
                             const VkBuffer *buffers,
                             const VkDeviceSize *offsets);
  
      void blitImage(const Image &srcImage,
                     VkImageLayout srcImageLayout,
                     const Image &dstImage,
                     VkImageLayout dstImageLayout,
                     uint32_t regionCount,
                     const VkImageBlit *regions,
                     VkFilter filter);
  
      void bufferBarrier(VkPipelineStageFlags srcStageMask,
                         VkPipelineStageFlags dstStageMask,
                         const VkBufferMemoryBarrier *bufferMemoryBarrier);
  
      void clearAttachments(uint32_t attachmentCount,
                            const VkClearAttachment *attachments,
                            uint32_t rectCount,
                            const VkClearRect *rects);
  
      void clearColorImage(const Image &image,
                           VkImageLayout imageLayout,
                           const VkClearColorValue &color,
                           uint32_t rangeCount,
                           const VkImageSubresourceRange *ranges);
  
      void clearDepthStencilImage(const Image &image,
                                  VkImageLayout imageLayout,
                                  const VkClearDepthStencilValue &depthStencil,
                                  uint32_t rangeCount,
                                  const VkImageSubresourceRange *ranges);
  
      void copyBuffer(const Buffer &srcBuffer,
                      const Buffer &destBuffer,
                      uint32_t regionCount,
                      const VkBufferCopy *regions);
  
      void copyBufferToImage(VkBuffer srcBuffer,
                             const Image &dstImage,
                             VkImageLayout dstImageLayout,
                             uint32_t regionCount,
                             const VkBufferImageCopy *regions);
  
      void copyImage(const Image &srcImage,
                     VkImageLayout srcImageLayout,
                     const Image &dstImage,
                     VkImageLayout dstImageLayout,
                     uint32_t regionCount,
                     const VkImageCopy *regions);
  
      void copyImageToBuffer(const Image &srcImage,
                             VkImageLayout srcImageLayout,
                             VkBuffer dstBuffer,
                             uint32_t regionCount,
                             const VkBufferImageCopy *regions);
  
      void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
  
      void dispatchIndirect(const Buffer &buffer, VkDeviceSize offset);
  
      void draw(uint32_t vertexCount, uint32_t firstVertex);
  
      void drawIndexed(uint32_t indexCount);
      void drawIndexedBaseVertex(uint32_t indexCount, uint32_t vertexOffset);
  
      void drawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount);
      void drawIndexedInstancedBaseVertex(uint32_t indexCount,
                                          uint32_t instanceCount,
                                          uint32_t vertexOffset);
      void drawIndexedInstancedBaseVertexBaseInstance(uint32_t indexCount,
                                                      uint32_t instanceCount,
                                                      uint32_t firstIndex,
                                                      int32_t vertexOffset,
                                                      uint32_t firstInstance);
  
      void drawInstanced(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex);
      void drawInstancedBaseInstance(uint32_t vertexCount,
                                     uint32_t instanceCount,
                                     uint32_t firstVertex,
                                     uint32_t firstInstance);
  
      void drawIndirect(const Buffer &buffer,
                        VkDeviceSize offset,
                        uint32_t drawCount,
                        uint32_t stride);
      void drawIndexedIndirect(const Buffer &buffer,
                               VkDeviceSize offset,
                               uint32_t drawCount,
                               uint32_t stride);
  
      void endQuery(VkQueryPool queryPool, uint32_t query);
  
      void executionBarrier(VkPipelineStageFlags stageMask);
  
      void fillBuffer(const Buffer &dstBuffer,
                      VkDeviceSize dstOffset,
                      VkDeviceSize size,
                      uint32_t data);
  
      void imageBarrier(VkPipelineStageFlags srcStageMask,
                        VkPipelineStageFlags dstStageMask,
                        const VkImageMemoryBarrier *imageMemoryBarrier);
  
      void memoryBarrier(VkPipelineStageFlags srcStageMask,
                         VkPipelineStageFlags dstStageMask,
                         const VkMemoryBarrier *memoryBarrier);
  
      void pipelineBarrier(VkPipelineStageFlags srcStageMask,
                           VkPipelineStageFlags dstStageMask,
                           VkDependencyFlags dependencyFlags,
                           uint32_t memoryBarrierCount,
                           const VkMemoryBarrier *memoryBarriers,
                           uint32_t bufferMemoryBarrierCount,
                           const VkBufferMemoryBarrier *bufferMemoryBarriers,
                           uint32_t imageMemoryBarrierCount,
                           const VkImageMemoryBarrier *imageMemoryBarriers);
  
      void pushConstants(const PipelineLayout &layout,
                         VkShaderStageFlags flag,
                         uint32_t offset,
                         uint32_t size,
                         const void *data);
  
      void resetEvent(VkEvent event, VkPipelineStageFlags stageMask);
  
      void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
  
      void resolveImage(const Image &srcImage,
                        VkImageLayout srcImageLayout,
                        const Image &dstImage,
                        VkImageLayout dstImageLayout,
                        uint32_t regionCount,
                        const VkImageResolve *regions);
  
      void setEvent(VkEvent event, VkPipelineStageFlags stageMask);
  
      void waitEvents(uint32_t eventCount,
                      const VkEvent *events,
                      VkPipelineStageFlags srcStageMask,
                      VkPipelineStageFlags dstStageMask,
                      uint32_t memoryBarrierCount,
                      const VkMemoryBarrier *memoryBarriers,
                      uint32_t bufferMemoryBarrierCount,
                      const VkBufferMemoryBarrier *bufferMemoryBarriers,
                      uint32_t imageMemoryBarrierCount,
                      const VkImageMemoryBarrier *imageMemoryBarriers);
  
      void writeTimestamp(VkPipelineStageFlagBits pipelineStage,
                          VkQueryPool queryPool,
                          uint32_t query);
      // No-op for compatibility
      VkResult end() { return VK_SUCCESS; }
  
      // Parse the cmds in this cmd buffer into given primary cmd buffer for execution
      void executeCommands(VkCommandBuffer cmdBuffer);
  
      // Calculate memory usage of this command buffer for diagnostics.
      void getMemoryUsageStats(size_t *usedMemoryOut, size_t *allocatedMemoryOut) const;
  
      // Traverse the list of commands and build a summary for diagnostics.
      std::string dumpCommands(const char *separator) const;
  
      // Pool Alloc uses 16kB pages w/ 16byte header = 16368bytes. To minimize waste
      //  using a 16368/12 = 1364. Also better perf than 1024 due to fewer block allocations
      static constexpr size_t kBlockSize = 1364;
      // Make sure block size is 4-byte aligned to avoid Android errors
      static_assert((kBlockSize % 4) == 0, "Check kBlockSize alignment");
  
      // Initialize the SecondaryCommandBuffer by setting the allocator it will use
      void initialize(angle::PoolAllocator *allocator)
      {
          ASSERT(allocator);
          mAllocator = allocator;
          allocateNewBlock();
          // Set first command to Invalid to start
          reinterpret_cast<CommandHeader *>(mCurrentWritePointer)->id = CommandID::Invalid;
      }
  
      // This will cause the SecondaryCommandBuffer to become invalid by clearing its allocator
      void releaseHandle() { mAllocator = nullptr; }
      // The SecondaryCommandBuffer is valid if it's been initialized
      bool valid() const { return mAllocator != nullptr; }
  
      static bool CanKnowIfEmpty() { return true; }
      bool empty() const { return mCommands.size() == 0 || mCommands[0]->id == CommandID::Invalid; }
  
    private:
      template <class StructType>
      ANGLE_INLINE StructType *commonInit(CommandID cmdID, size_t allocationSize)
      {
          mCurrentBytesRemaining -= allocationSize;
  
          CommandHeader *header = reinterpret_cast<CommandHeader *>(mCurrentWritePointer);
          header->id            = cmdID;
          header->size          = static_cast<uint16_t>(allocationSize);
          ASSERT(allocationSize <= std::numeric_limits<uint16_t>::max());
  
          mCurrentWritePointer += allocationSize;
          // Set next cmd header to Invalid (0) so cmd sequence will be terminated
          reinterpret_cast<CommandHeader *>(mCurrentWritePointer)->id = CommandID::Invalid;
          return Offset<StructType>(header, sizeof(CommandHeader));
      }
      ANGLE_INLINE void allocateNewBlock()
      {
          ASSERT(mAllocator);
          mCurrentWritePointer   = mAllocator->fastAllocate(kBlockSize);
          mCurrentBytesRemaining = kBlockSize;
          mCommands.push_back(reinterpret_cast<CommandHeader *>(mCurrentWritePointer));
      }
  
      // Allocate and initialize memory for given commandID & variable param size, setting
      // variableDataPtr to the byte following fixed cmd data where variable-sized ptr data will
      // be written and returning a pointer to the start of the command's parameter data
      template <class StructType>
      ANGLE_INLINE StructType *initCommand(CommandID cmdID,
                                           size_t variableSize,
                                           uint8_t **variableDataPtr)
      {
          constexpr size_t fixedAllocationSize = sizeof(StructType) + sizeof(CommandHeader);
          const size_t allocationSize          = fixedAllocationSize + variableSize;
          // Make sure we have enough room to mark follow-on header "Invalid"
          if (mCurrentBytesRemaining <= (allocationSize + sizeof(CommandHeader)))
          {
              allocateNewBlock();
          }
          *variableDataPtr = Offset<uint8_t>(mCurrentWritePointer, fixedAllocationSize);
          return commonInit<StructType>(cmdID, allocationSize);
      }
  
      // Initialize a command that doesn't have variable-sized ptr data
      template <class StructType>
      ANGLE_INLINE StructType *initCommand(CommandID cmdID)
      {
          constexpr size_t allocationSize = sizeof(StructType) + sizeof(CommandHeader);
          // Make sure we have enough room to mark follow-on header "Invalid"
          if (mCurrentBytesRemaining <= (allocationSize + sizeof(CommandHeader)))
          {
              allocateNewBlock();
          }
          return commonInit<StructType>(cmdID, allocationSize);
      }
  
      // Return a ptr to the parameter type
      template <class StructType>
      const StructType *getParamPtr(const CommandHeader *header) const
      {
          return reinterpret_cast<const StructType *>(reinterpret_cast<const uint8_t *>(header) +
                                                      sizeof(CommandHeader));
      }
      // Copy sizeInBytes data from paramData to writePointer & return writePointer plus sizeInBytes.
      template <class PtrType>
      ANGLE_INLINE uint8_t *storePointerParameter(uint8_t *writePointer,
                                                  const PtrType *paramData,
                                                  size_t sizeInBytes)
      {
          memcpy(writePointer, paramData, sizeInBytes);
          return writePointer + sizeInBytes;
      }
  
      std::vector<CommandHeader *> mCommands;
  
      // Allocator used by this class. If non-null then the class is valid.
      angle::PoolAllocator *mAllocator;
  
      uint8_t *mCurrentWritePointer;
      size_t mCurrentBytesRemaining;
  };
  
  ANGLE_INLINE SecondaryCommandBuffer::SecondaryCommandBuffer()
      : mAllocator(nullptr), mCurrentWritePointer(nullptr), mCurrentBytesRemaining(0)
  {}
  ANGLE_INLINE SecondaryCommandBuffer::~SecondaryCommandBuffer() {}
  
  ANGLE_INLINE void SecondaryCommandBuffer::beginQuery(VkQueryPool queryPool,
                                                       uint32_t query,
                                                       VkQueryControlFlags flags)
  {
      BeginQueryParams *paramStruct = initCommand<BeginQueryParams>(CommandID::BeginQuery);
      paramStruct->queryPool        = queryPool;
      paramStruct->query            = query;
      paramStruct->flags            = flags;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bindComputePipeline(const Pipeline &pipeline)
  {
      BindPipelineParams *paramStruct =
          initCommand<BindPipelineParams>(CommandID::BindComputePipeline);
      paramStruct->pipeline = pipeline.getHandle();
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bindDescriptorSets(const PipelineLayout &layout,
                                                               VkPipelineBindPoint pipelineBindPoint,
                                                               uint32_t firstSet,
                                                               uint32_t descriptorSetCount,
                                                               const VkDescriptorSet *descriptorSets,
                                                               uint32_t dynamicOffsetCount,
                                                               const uint32_t *dynamicOffsets)
  {
      size_t descSize   = descriptorSetCount * sizeof(VkDescriptorSet);
      size_t offsetSize = dynamicOffsetCount * sizeof(uint32_t);
      uint8_t *writePtr;
      BindDescriptorSetParams *paramStruct = initCommand<BindDescriptorSetParams>(
          CommandID::BindDescriptorSets, descSize + offsetSize, &writePtr);
      // Copy params into memory
      paramStruct->layout             = layout.getHandle();
      paramStruct->pipelineBindPoint  = pipelineBindPoint;
      paramStruct->firstSet           = firstSet;
      paramStruct->descriptorSetCount = descriptorSetCount;
      paramStruct->dynamicOffsetCount = dynamicOffsetCount;
      // Copy variable sized data
      writePtr = storePointerParameter(writePtr, descriptorSets, descSize);
      storePointerParameter(writePtr, dynamicOffsets, offsetSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bindGraphicsPipeline(const Pipeline &pipeline)
  {
      BindPipelineParams *paramStruct =
          initCommand<BindPipelineParams>(CommandID::BindGraphicsPipeline);
      paramStruct->pipeline = pipeline.getHandle();
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bindIndexBuffer(const Buffer &buffer,
                                                            VkDeviceSize offset,
                                                            VkIndexType indexType)
  {
      BindIndexBufferParams *paramStruct =
          initCommand<BindIndexBufferParams>(CommandID::BindIndexBuffer);
      paramStruct->buffer    = buffer.getHandle();
      paramStruct->offset    = offset;
      paramStruct->indexType = indexType;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bindVertexBuffers(uint32_t firstBinding,
                                                              uint32_t bindingCount,
                                                              const VkBuffer *buffers,
                                                              const VkDeviceSize *offsets)
  {
      ASSERT(firstBinding == 0);
      uint8_t *writePtr;
      size_t buffersSize                   = bindingCount * sizeof(VkBuffer);
      size_t offsetsSize                   = bindingCount * sizeof(VkDeviceSize);
      BindVertexBuffersParams *paramStruct = initCommand<BindVertexBuffersParams>(
          CommandID::BindVertexBuffers, buffersSize + offsetsSize, &writePtr);
      // Copy params
      paramStruct->bindingCount = bindingCount;
      writePtr                  = storePointerParameter(writePtr, buffers, buffersSize);
      storePointerParameter(writePtr, offsets, offsetsSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::blitImage(const Image &srcImage,
                                                      VkImageLayout srcImageLayout,
                                                      const Image &dstImage,
                                                      VkImageLayout dstImageLayout,
                                                      uint32_t regionCount,
                                                      const VkImageBlit *regions,
                                                      VkFilter filter)
  {
      // Currently ANGLE uses limited params so verify those assumptions and update if they change
      ASSERT(srcImageLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
      ASSERT(dstImageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
      ASSERT(regionCount == 1);
      BlitImageParams *paramStruct = initCommand<BlitImageParams>(CommandID::BlitImage);
      paramStruct->srcImage        = srcImage.getHandle();
      paramStruct->dstImage        = dstImage.getHandle();
      paramStruct->filter          = filter;
      paramStruct->region          = regions[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::bufferBarrier(
      VkPipelineStageFlags srcStageMask,
      VkPipelineStageFlags dstStageMask,
      const VkBufferMemoryBarrier *bufferMemoryBarrier)
  {
      BufferBarrierParams *paramStruct = initCommand<BufferBarrierParams>(CommandID::BufferBarrier);
      paramStruct->srcStageMask        = srcStageMask;
      paramStruct->dstStageMask        = dstStageMask;
      paramStruct->bufferMemoryBarrier = *bufferMemoryBarrier;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::clearAttachments(uint32_t attachmentCount,
                                                             const VkClearAttachment *attachments,
                                                             uint32_t rectCount,
                                                             const VkClearRect *rects)
  {
      ASSERT(rectCount == 1);
      uint8_t *writePtr;
      size_t attachSize = attachmentCount * sizeof(VkClearAttachment);
      ClearAttachmentsParams *paramStruct =
          initCommand<ClearAttachmentsParams>(CommandID::ClearAttachments, attachSize, &writePtr);
      paramStruct->attachmentCount = attachmentCount;
      paramStruct->rect            = rects[0];
      // Copy variable sized data
      storePointerParameter(writePtr, attachments, attachSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::clearColorImage(const Image &image,
                                                            VkImageLayout imageLayout,
                                                            const VkClearColorValue &color,
                                                            uint32_t rangeCount,
                                                            const VkImageSubresourceRange *ranges)
  {
      ASSERT(rangeCount == 1);
      ClearColorImageParams *paramStruct =
          initCommand<ClearColorImageParams>(CommandID::ClearColorImage);
      paramStruct->image       = image.getHandle();
      paramStruct->imageLayout = imageLayout;
      paramStruct->color       = color;
      paramStruct->range       = ranges[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::clearDepthStencilImage(
      const Image &image,
      VkImageLayout imageLayout,
      const VkClearDepthStencilValue &depthStencil,
      uint32_t rangeCount,
      const VkImageSubresourceRange *ranges)
  {
      ASSERT(rangeCount == 1);
      ClearDepthStencilImageParams *paramStruct =
          initCommand<ClearDepthStencilImageParams>(CommandID::ClearDepthStencilImage);
      paramStruct->image        = image.getHandle();
      paramStruct->imageLayout  = imageLayout;
      paramStruct->depthStencil = depthStencil;
      paramStruct->range        = ranges[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::copyBuffer(const Buffer &srcBuffer,
                                                       const Buffer &destBuffer,
                                                       uint32_t regionCount,
                                                       const VkBufferCopy *regions)
  {
      uint8_t *writePtr;
      size_t regionSize = regionCount * sizeof(VkBufferCopy);
      CopyBufferParams *paramStruct =
          initCommand<CopyBufferParams>(CommandID::CopyBuffer, regionSize, &writePtr);
      paramStruct->srcBuffer   = srcBuffer.getHandle();
      paramStruct->destBuffer  = destBuffer.getHandle();
      paramStruct->regionCount = regionCount;
      // Copy variable sized data
      storePointerParameter(writePtr, regions, regionSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::copyBufferToImage(VkBuffer srcBuffer,
                                                              const Image &dstImage,
                                                              VkImageLayout dstImageLayout,
                                                              uint32_t regionCount,
                                                              const VkBufferImageCopy *regions)
  {
      ASSERT(regionCount == 1);
      CopyBufferToImageParams *paramStruct =
          initCommand<CopyBufferToImageParams>(CommandID::CopyBufferToImage);
      paramStruct->srcBuffer      = srcBuffer;
      paramStruct->dstImage       = dstImage.getHandle();
      paramStruct->dstImageLayout = dstImageLayout;
      paramStruct->region         = regions[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::copyImage(const Image &srcImage,
                                                      VkImageLayout srcImageLayout,
                                                      const Image &dstImage,
                                                      VkImageLayout dstImageLayout,
                                                      uint32_t regionCount,
                                                      const VkImageCopy *regions)
  {
      ASSERT(regionCount == 1);
      CopyImageParams *paramStruct = initCommand<CopyImageParams>(CommandID::CopyImage);
      paramStruct->srcImage        = srcImage.getHandle();
      paramStruct->srcImageLayout  = srcImageLayout;
      paramStruct->dstImage        = dstImage.getHandle();
      paramStruct->dstImageLayout  = dstImageLayout;
      paramStruct->region          = regions[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::copyImageToBuffer(const Image &srcImage,
                                                              VkImageLayout srcImageLayout,
                                                              VkBuffer dstBuffer,
                                                              uint32_t regionCount,
                                                              const VkBufferImageCopy *regions)
  {
      ASSERT(regionCount == 1);
      CopyImageToBufferParams *paramStruct =
          initCommand<CopyImageToBufferParams>(CommandID::CopyImageToBuffer);
      paramStruct->srcImage       = srcImage.getHandle();
      paramStruct->srcImageLayout = srcImageLayout;
      paramStruct->dstBuffer      = dstBuffer;
      paramStruct->region         = regions[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::dispatch(uint32_t groupCountX,
                                                     uint32_t groupCountY,
                                                     uint32_t groupCountZ)
  {
      DispatchParams *paramStruct = initCommand<DispatchParams>(CommandID::Dispatch);
      paramStruct->groupCountX    = groupCountX;
      paramStruct->groupCountY    = groupCountY;
      paramStruct->groupCountZ    = groupCountZ;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::dispatchIndirect(const Buffer &buffer,
                                                             VkDeviceSize offset)
  {
      DispatchIndirectParams *paramStruct =
          initCommand<DispatchIndirectParams>(CommandID::DispatchIndirect);
      paramStruct->buffer = buffer.getHandle();
      paramStruct->offset = offset;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::draw(uint32_t vertexCount, uint32_t firstVertex)
  {
      DrawParams *paramStruct  = initCommand<DrawParams>(CommandID::Draw);
      paramStruct->vertexCount = vertexCount;
      paramStruct->firstVertex = firstVertex;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexed(uint32_t indexCount)
  {
      DrawIndexedParams *paramStruct = initCommand<DrawIndexedParams>(CommandID::DrawIndexed);
      paramStruct->indexCount        = indexCount;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedBaseVertex(uint32_t indexCount,
                                                                  uint32_t vertexOffset)
  {
      DrawIndexedBaseVertexParams *paramStruct =
          initCommand<DrawIndexedBaseVertexParams>(CommandID::DrawIndexedBaseVertex);
      paramStruct->indexCount   = indexCount;
      paramStruct->vertexOffset = vertexOffset;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstanced(uint32_t indexCount,
                                                                 uint32_t instanceCount)
  {
      DrawIndexedInstancedParams *paramStruct =
          initCommand<DrawIndexedInstancedParams>(CommandID::DrawIndexedInstanced);
      paramStruct->indexCount    = indexCount;
      paramStruct->instanceCount = instanceCount;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstancedBaseVertex(uint32_t indexCount,
                                                                           uint32_t instanceCount,
                                                                           uint32_t vertexOffset)
  {
      DrawIndexedInstancedBaseVertexParams *paramStruct =
          initCommand<DrawIndexedInstancedBaseVertexParams>(
              CommandID::DrawIndexedInstancedBaseVertex);
      paramStruct->indexCount    = indexCount;
      paramStruct->instanceCount = instanceCount;
      paramStruct->vertexOffset  = vertexOffset;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstancedBaseVertexBaseInstance(
      uint32_t indexCount,
      uint32_t instanceCount,
      uint32_t firstIndex,
      int32_t vertexOffset,
      uint32_t firstInstance)
  {
      DrawIndexedInstancedBaseVertexBaseInstanceParams *paramStruct =
          initCommand<DrawIndexedInstancedBaseVertexBaseInstanceParams>(
              CommandID::DrawIndexedInstancedBaseVertexBaseInstance);
      paramStruct->indexCount    = indexCount;
      paramStruct->instanceCount = instanceCount;
      paramStruct->firstIndex    = firstIndex;
      paramStruct->vertexOffset  = vertexOffset;
      paramStruct->firstInstance = firstInstance;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawInstanced(uint32_t vertexCount,
                                                          uint32_t instanceCount,
                                                          uint32_t firstVertex)
  {
      DrawInstancedParams *paramStruct = initCommand<DrawInstancedParams>(CommandID::DrawInstanced);
      paramStruct->vertexCount         = vertexCount;
      paramStruct->instanceCount       = instanceCount;
      paramStruct->firstVertex         = firstVertex;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawInstancedBaseInstance(uint32_t vertexCount,
                                                                      uint32_t instanceCount,
                                                                      uint32_t firstVertex,
                                                                      uint32_t firstInstance)
  {
      DrawInstancedBaseInstanceParams *paramStruct =
          initCommand<DrawInstancedBaseInstanceParams>(CommandID::DrawInstancedBaseInstance);
      paramStruct->vertexCount   = vertexCount;
      paramStruct->instanceCount = instanceCount;
      paramStruct->firstVertex   = firstVertex;
      paramStruct->firstInstance = firstInstance;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndirect(const Buffer &buffer,
                                                         VkDeviceSize offset,
                                                         uint32_t drawCount,
                                                         uint32_t stride)
  {
      DrawIndirectParams *paramStruct = initCommand<DrawIndirectParams>(CommandID::DrawIndirect);
      paramStruct->buffer             = buffer.getHandle();
      paramStruct->offset             = offset;
  
      // OpenGL ES doesn't have a way to specify a drawCount or stride, throw assert if something
      // changes.
      ASSERT(drawCount == 1);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedIndirect(const Buffer &buffer,
                                                                VkDeviceSize offset,
                                                                uint32_t drawCount,
                                                                uint32_t stride)
  {
      DrawIndexedIndirectParams *paramStruct =
          initCommand<DrawIndexedIndirectParams>(CommandID::DrawIndexedIndirect);
      paramStruct->buffer = buffer.getHandle();
      paramStruct->offset = offset;
      ASSERT(drawCount == 1);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::endQuery(VkQueryPool queryPool, uint32_t query)
  {
      EndQueryParams *paramStruct = initCommand<EndQueryParams>(CommandID::EndQuery);
      paramStruct->queryPool      = queryPool;
      paramStruct->query          = query;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::executionBarrier(VkPipelineStageFlags stageMask)
  {
      ExecutionBarrierParams *paramStruct =
          initCommand<ExecutionBarrierParams>(CommandID::ExecutionBarrier);
      paramStruct->stageMask = stageMask;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::fillBuffer(const Buffer &dstBuffer,
                                                       VkDeviceSize dstOffset,
                                                       VkDeviceSize size,
                                                       uint32_t data)
  {
      FillBufferParams *paramStruct = initCommand<FillBufferParams>(CommandID::FillBuffer);
      paramStruct->dstBuffer        = dstBuffer.getHandle();
      paramStruct->dstOffset        = dstOffset;
      paramStruct->size             = size;
      paramStruct->data             = data;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::imageBarrier(
      VkPipelineStageFlags srcStageMask,
      VkPipelineStageFlags dstStageMask,
      const VkImageMemoryBarrier *imageMemoryBarrier)
  {
      ImageBarrierParams *paramStruct = initCommand<ImageBarrierParams>(CommandID::ImageBarrier);
      paramStruct->srcStageMask       = srcStageMask;
      paramStruct->dstStageMask       = dstStageMask;
      paramStruct->imageMemoryBarrier = *imageMemoryBarrier;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::memoryBarrier(VkPipelineStageFlags srcStageMask,
                                                          VkPipelineStageFlags dstStageMask,
                                                          const VkMemoryBarrier *memoryBarrier)
  {
      MemoryBarrierParams *paramStruct = initCommand<MemoryBarrierParams>(CommandID::MemoryBarrier);
      paramStruct->srcStageMask        = srcStageMask;
      paramStruct->dstStageMask        = dstStageMask;
      paramStruct->memoryBarrier       = *memoryBarrier;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::pipelineBarrier(
      VkPipelineStageFlags srcStageMask,
      VkPipelineStageFlags dstStageMask,
      VkDependencyFlags dependencyFlags,
      uint32_t memoryBarrierCount,
      const VkMemoryBarrier *memoryBarriers,
      uint32_t bufferMemoryBarrierCount,
      const VkBufferMemoryBarrier *bufferMemoryBarriers,
      uint32_t imageMemoryBarrierCount,
      const VkImageMemoryBarrier *imageMemoryBarriers)
  {
      uint8_t *writePtr;
      size_t memBarrierSize              = memoryBarrierCount * sizeof(VkMemoryBarrier);
      size_t buffBarrierSize             = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
      size_t imgBarrierSize              = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
      PipelineBarrierParams *paramStruct = initCommand<PipelineBarrierParams>(
          CommandID::PipelineBarrier, memBarrierSize + buffBarrierSize + imgBarrierSize, &writePtr);
      paramStruct->srcStageMask             = srcStageMask;
      paramStruct->dstStageMask             = dstStageMask;
      paramStruct->dependencyFlags          = dependencyFlags;
      paramStruct->memoryBarrierCount       = memoryBarrierCount;
      paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
      paramStruct->imageMemoryBarrierCount  = imageMemoryBarrierCount;
      // Copy variable sized data
      writePtr = storePointerParameter(writePtr, memoryBarriers, memBarrierSize);
      writePtr = storePointerParameter(writePtr, bufferMemoryBarriers, buffBarrierSize);
      storePointerParameter(writePtr, imageMemoryBarriers, imgBarrierSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::pushConstants(const PipelineLayout &layout,
                                                          VkShaderStageFlags flag,
                                                          uint32_t offset,
                                                          uint32_t size,
                                                          const void *data)
  {
      ASSERT(size == static_cast<size_t>(size));
      uint8_t *writePtr;
      PushConstantsParams *paramStruct = initCommand<PushConstantsParams>(
          CommandID::PushConstants, static_cast<size_t>(size), &writePtr);
      paramStruct->layout = layout.getHandle();
      paramStruct->flag   = flag;
      paramStruct->offset = offset;
      paramStruct->size   = size;
      // Copy variable sized data
      storePointerParameter(writePtr, data, static_cast<size_t>(size));
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::resetEvent(VkEvent event, VkPipelineStageFlags stageMask)
  {
      ResetEventParams *paramStruct = initCommand<ResetEventParams>(CommandID::ResetEvent);
      paramStruct->event            = event;
      paramStruct->stageMask        = stageMask;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::resetQueryPool(VkQueryPool queryPool,
                                                           uint32_t firstQuery,
                                                           uint32_t queryCount)
  {
      ResetQueryPoolParams *paramStruct =
          initCommand<ResetQueryPoolParams>(CommandID::ResetQueryPool);
      paramStruct->queryPool  = queryPool;
      paramStruct->firstQuery = firstQuery;
      paramStruct->queryCount = queryCount;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::resolveImage(const Image &srcImage,
                                                         VkImageLayout srcImageLayout,
                                                         const Image &dstImage,
                                                         VkImageLayout dstImageLayout,
                                                         uint32_t regionCount,
                                                         const VkImageResolve *regions)
  {
      // Currently ANGLE uses limited params so verify those assumptions and update if they change.
      ASSERT(srcImageLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
      ASSERT(dstImageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
      ASSERT(regionCount == 1);
      ResolveImageParams *paramStruct = initCommand<ResolveImageParams>(CommandID::ResolveImage);
      paramStruct->srcImage           = srcImage.getHandle();
      paramStruct->dstImage           = dstImage.getHandle();
      paramStruct->region             = regions[0];
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::setEvent(VkEvent event, VkPipelineStageFlags stageMask)
  {
      SetEventParams *paramStruct = initCommand<SetEventParams>(CommandID::SetEvent);
      paramStruct->event          = event;
      paramStruct->stageMask      = stageMask;
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::waitEvents(
      uint32_t eventCount,
      const VkEvent *events,
      VkPipelineStageFlags srcStageMask,
      VkPipelineStageFlags dstStageMask,
      uint32_t memoryBarrierCount,
      const VkMemoryBarrier *memoryBarriers,
      uint32_t bufferMemoryBarrierCount,
      const VkBufferMemoryBarrier *bufferMemoryBarriers,
      uint32_t imageMemoryBarrierCount,
      const VkImageMemoryBarrier *imageMemoryBarriers)
  {
      uint8_t *writePtr;
      size_t eventSize              = eventCount * sizeof(VkEvent);
      size_t memBarrierSize         = memoryBarrierCount * sizeof(VkMemoryBarrier);
      size_t buffBarrierSize        = bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier);
      size_t imgBarrierSize         = imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier);
      WaitEventsParams *paramStruct = initCommand<WaitEventsParams>(
          CommandID::WaitEvents, eventSize + memBarrierSize + buffBarrierSize + imgBarrierSize,
          &writePtr);
      paramStruct->eventCount               = eventCount;
      paramStruct->srcStageMask             = srcStageMask;
      paramStruct->dstStageMask             = dstStageMask;
      paramStruct->memoryBarrierCount       = memoryBarrierCount;
      paramStruct->bufferMemoryBarrierCount = bufferMemoryBarrierCount;
      paramStruct->imageMemoryBarrierCount  = imageMemoryBarrierCount;
      // Copy variable sized data
      writePtr = storePointerParameter(writePtr, events, eventSize);
      writePtr = storePointerParameter(writePtr, memoryBarriers, memBarrierSize);
      writePtr = storePointerParameter(writePtr, bufferMemoryBarriers, buffBarrierSize);
      storePointerParameter(writePtr, imageMemoryBarriers, imgBarrierSize);
  }
  
  ANGLE_INLINE void SecondaryCommandBuffer::writeTimestamp(VkPipelineStageFlagBits pipelineStage,
                                                           VkQueryPool queryPool,
                                                           uint32_t query)
  {
      WriteTimestampParams *paramStruct =
          initCommand<WriteTimestampParams>(CommandID::WriteTimestamp);
      paramStruct->pipelineStage = pipelineStage;
      paramStruct->queryPool     = queryPool;
      paramStruct->query         = query;
  }
  }  // namespace priv
  }  // namespace vk
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_SECONDARYCOMMANDBUFFERVK_H_
  

Download