impeller::ComputePassVK Class Reference

#include <compute_pass_vk.h>

Inheritance diagram for impeller::ComputePassVK:

Public Member Functions
	~ComputePassVK () override
Public Member Functions inherited from impeller::ComputePass
virtual	~ComputePass ()
void	SetLabel (const std::string &label)
const Context &	GetContext () const
Public Member Functions inherited from impeller::ResourceBinder
virtual	~ResourceBinder ()=default

Private Member Functions
bool	IsValid () const override
void	OnSetLabel (const std::string &label) override
bool	EncodeCommands () const override
	Encode the recorded commands to the underlying command buffer.
void	SetCommandLabel (std::string_view label) override
void	SetPipeline (const std::shared_ptr< Pipeline< ComputePipelineDescriptor > > &pipeline) override
void	AddBufferMemoryBarrier () override
	Ensures all previously encoded compute command's buffer writes are visible to any subsequent compute commands.
void	AddTextureMemoryBarrier () override
	Ensures all previously encoded compute command's texture writes are visible to any subsequent compute commands.
fml::Status	Compute (const ISize &grid_size) override
bool	BindResource (ShaderStage stage, DescriptorType type, const ShaderUniformSlot &slot, const ShaderMetadata &metadata, BufferView view) override
bool	BindResource (ShaderStage stage, DescriptorType type, const SampledImageSlot &slot, const ShaderMetadata &metadata, std::shared_ptr< const Texture > texture, const std::unique_ptr< const Sampler > &sampler) override

Friends
class	CommandBufferVK

Additional Inherited Members
Protected Member Functions inherited from impeller::ComputePass
	ComputePass (std::shared_ptr< const Context > context)
Protected Attributes inherited from impeller::ComputePass
const std::shared_ptr< const Context >	context_

Detailed Description

Definition at line 15 of file compute_pass_vk.h.

Constructor & Destructor Documentation

~ComputePassVK()

impeller::ComputePassVK::~ComputePassVK ( )

overridedefault

Member Function Documentation

AddBufferMemoryBarrier()

void impeller::ComputePassVK::AddBufferMemoryBarrier ( )

overrideprivatevirtual

Ensures all previously encoded compute command's buffer writes are visible to any subsequent compute commands.

On Vulkan, it does not matter if the compute command is in a different command buffer, only that it is executed later in queue order.

Implements impeller::ComputePass.

Definition at line 222 of file compute_pass_vk.cc.

                                           {
  vk::MemoryBarrier barrier;
  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
  barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
      vk::PipelineStageFlagBits::eComputeShader,
      vk::PipelineStageFlagBits::eComputeShader, {}, 1, &barrier, 0, {}, 0, {});
}

AddTextureMemoryBarrier()

void impeller::ComputePassVK::AddTextureMemoryBarrier ( )

overrideprivatevirtual

Ensures all previously encoded compute command's texture writes are visible to any subsequent compute commands.

On Vulkan, it does not matter if the compute command is in a different command buffer, only that it is executed later in queue order.

Implements impeller::ComputePass.

Definition at line 233 of file compute_pass_vk.cc.

                                            {
  vk::MemoryBarrier barrier;
  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
  barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
      vk::PipelineStageFlagBits::eComputeShader,
      vk::PipelineStageFlagBits::eComputeShader, {}, 1, &barrier, 0, {}, 0, {});
}

BindResource() [1/2]

bool impeller::ComputePassVK::BindResource ( ShaderStage  stage, DescriptorType  type, const SampledImageSlot &  slot, const ShaderMetadata &  metadata, std::shared_ptr< const Texture >  texture, const std::unique_ptr< const Sampler > &  sampler  )

overrideprivatevirtual

Implements impeller::ResourceBinder.

Definition at line 144 of file compute_pass_vk.cc.

                                                 {
  if (bound_image_offset_ >= kMaxBindings) {
    return false;
  }
  if (!texture->IsValid() || !sampler) {
    return false;
  }
  const TextureVK& texture_vk = TextureVK::Cast(*texture);
  const SamplerVK& sampler_vk = SamplerVK::Cast(*sampler);
 
  if (!command_buffer_->GetEncoder()->Track(texture)) {
    return false;
  }
 
  vk::DescriptorImageInfo image_info;
  image_info.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
  image_info.sampler = sampler_vk.GetSampler();
  image_info.imageView = texture_vk.GetImageView();
  image_workspace_[bound_image_offset_++] = image_info;
 
  vk::WriteDescriptorSet write_set;
  write_set.dstBinding = slot.binding;
  write_set.descriptorCount = 1u;
  write_set.descriptorType = ToVKDescriptorType(type);
  write_set.pImageInfo = &image_workspace_[bound_image_offset_ - 1];
 
  write_workspace_[descriptor_write_offset_++] = write_set;
  return true;
}

BindResource() [2/2]

bool impeller::ComputePassVK::BindResource ( ShaderStage  stage, DescriptorType  type, const ShaderUniformSlot &  slot, const ShaderMetadata &  metadata, BufferView  view  )

overrideprivatevirtual

Implements impeller::ResourceBinder.

Definition at line 135 of file compute_pass_vk.cc.

                                                  {
  return BindResource(slot.binding, type, view);
}

Compute()

fml::Status impeller::ComputePassVK::Compute ( const ISize &  grid_size )

overrideprivatevirtual

Implements impeller::ComputePass.

Definition at line 71 of file compute_pass_vk.cc.

                                                       {
  if (grid_size.IsEmpty() || !pipeline_valid_) {
    bound_image_offset_ = 0u;
    bound_buffer_offset_ = 0u;
    descriptor_write_offset_ = 0u;
    has_label_ = false;
    pipeline_valid_ = false;
    return fml::Status(fml::StatusCode::kCancelled,
                       "Invalid pipeline or empty grid.");
  }
 
  const ContextVK& context_vk = ContextVK::Cast(*context_);
  for (auto i = 0u; i < descriptor_write_offset_; i++) {
    write_workspace_[i].dstSet = descriptor_set_;
  }
 
  context_vk.GetDevice().updateDescriptorSets(descriptor_write_offset_,
                                              write_workspace_.data(), 0u, {});
  const vk::CommandBuffer& command_buffer_vk =
      command_buffer_->GetEncoder()->GetCommandBuffer();
 
  command_buffer_vk.bindDescriptorSets(
      vk::PipelineBindPoint::eCompute,  // bind point
      pipeline_layout_,                 // layout
      0,                                // first set
      1,                                // set count
      &descriptor_set_,                 // sets
      0,                                // offset count
      nullptr                           // offsets
  );
 
  int64_t width = grid_size.width;
  int64_t height = grid_size.height;
 
  // Special case for linear processing.
  if (height == 1) {
    command_buffer_vk.dispatch(width, 1, 1);
  } else {
    while (width > max_wg_size_[0]) {
      width = std::max(static_cast<int64_t>(1), width / 2);
    }
    while (height > max_wg_size_[1]) {
      height = std::max(static_cast<int64_t>(1), height / 2);
    }
    command_buffer_vk.dispatch(width, height, 1);
  }
 
#ifdef IMPELLER_DEBUG
  if (has_label_) {
    command_buffer_->GetEncoder()->PopDebugGroup();
  }
  has_label_ = false;
#endif  // IMPELLER_DEBUG
 
  bound_image_offset_ = 0u;
  bound_buffer_offset_ = 0u;
  descriptor_write_offset_ = 0u;
  has_label_ = false;
  pipeline_valid_ = false;
 
  return fml::Status();
}

EncodeCommands()

bool impeller::ComputePassVK::EncodeCommands ( ) const

overrideprivatevirtual

Encode the recorded commands to the underlying command buffer.

Returns

If the commands were encoded to the underlying command buffer.

Implements impeller::ComputePass.

Definition at line 244 of file compute_pass_vk.cc.

                                         {
  // Since we only use global memory barrier, we don't have to worry about
  // compute to compute dependencies across cmd buffers. Instead, we pessimize
  // here and assume that we wrote to a storage image or buffer and that a
  // render pass will read from it. if there are ever scenarios where we end up
  // with compute to compute dependencies this should be revisited.
 
  // This does not currently handle image barriers as we do not use them
  // for anything.
  vk::MemoryBarrier barrier;
  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
  barrier.dstAccessMask =
      vk::AccessFlagBits::eIndexRead | vk::AccessFlagBits::eVertexAttributeRead;
 
  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
      vk::PipelineStageFlagBits::eComputeShader,
      vk::PipelineStageFlagBits::eVertexInput, {}, 1, &barrier, 0, {}, 0, {});
 
  return true;
}

IsValid()

bool impeller::ComputePassVK::IsValid ( ) const

overrideprivatevirtual

Implements impeller::ComputePass.

Definition at line 31 of file compute_pass_vk.cc.

                                  {
  return is_valid_;
}

OnSetLabel()

void impeller::ComputePassVK::OnSetLabel ( const std::string &  label )

overrideprivatevirtual

Implements impeller::ComputePass.

Definition at line 35 of file compute_pass_vk.cc.

                                                     {
  if (label.empty()) {
    return;
  }
  label_ = label;
}

SetCommandLabel()

void impeller::ComputePassVK::SetCommandLabel ( std::string_view  label )

overrideprivatevirtual

Implements impeller::ComputePass.

Definition at line 43 of file compute_pass_vk.cc.

                                                        {
#ifdef IMPELLER_DEBUG
  command_buffer_->GetEncoder()->PushDebugGroup(label);
  has_label_ = true;
#endif  // IMPELLER_DEBUG
}

SetPipeline()

void impeller::ComputePassVK::SetPipeline ( const std::shared_ptr< Pipeline< ComputePipelineDescriptor > > &  pipeline )

overrideprivatevirtual

Implements impeller::ComputePass.

Definition at line 51 of file compute_pass_vk.cc.

                                                                        {
  const auto& pipeline_vk = ComputePipelineVK::Cast(*pipeline);
  const vk::CommandBuffer& command_buffer_vk =
      command_buffer_->GetEncoder()->GetCommandBuffer();
  command_buffer_vk.bindPipeline(vk::PipelineBindPoint::eCompute,
                                 pipeline_vk.GetPipeline());
  pipeline_layout_ = pipeline_vk.GetPipelineLayout();
 
  auto descriptor_result =
      command_buffer_->GetEncoder()->AllocateDescriptorSets(
          pipeline_vk.GetDescriptorSetLayout(), ContextVK::Cast(*context_));
  if (!descriptor_result.ok()) {
    return;
  }
  descriptor_set_ = descriptor_result.value();
  pipeline_valid_ = true;
}

Friends And Related Symbol Documentation

CommandBufferVK

friend class CommandBufferVK

friend

Definition at line 21 of file compute_pass_vk.h.

---

The documentation for this class was generated from the following files:

• impeller/renderer/backend/vulkan/compute_pass_vk.h
• impeller/renderer/backend/vulkan/compute_pass_vk.cc