impeller::AllocatorVK Class Reference

#include <allocator_vk.h>

Inheritance diagram for impeller::AllocatorVK:

Public Member Functions
	~AllocatorVK () override
size_t	DebugGetHeapUsage () const
Public Member Functions inherited from impeller::Allocator
virtual	~Allocator ()
bool	IsValid () const
std::shared_ptr< DeviceBuffer >	CreateBuffer (const DeviceBufferDescriptor &desc)
std::shared_ptr< Texture >	CreateTexture (const TextureDescriptor &desc)
virtual uint16_t	MinimumBytesPerRow (PixelFormat format) const
	Minimum value for row_bytes on a Texture. The row bytes parameter of that method must be aligned to this value.
std::shared_ptr< DeviceBuffer >	CreateBufferWithCopy (const uint8_t *buffer, size_t length)
std::shared_ptr< DeviceBuffer >	CreateBufferWithCopy (const fml::Mapping &mapping)

Static Public Member Functions
static int32_t	FindMemoryTypeIndex (uint32_t memory_type_bits_requirement, vk::PhysicalDeviceMemoryProperties &memory_properties)
	Select a matching memory type for the given [memory_type_bits_requirement], or -1 if none is found.
static vk::ImageUsageFlags	ToVKImageUsageFlags (PixelFormat format, TextureUsageMask usage, StorageMode mode, bool supports_memoryless_textures)

Private Member Functions
std::shared_ptr< DeviceBuffer >	OnCreateBuffer (const DeviceBufferDescriptor &desc) override
std::shared_ptr< Texture >	OnCreateTexture (const TextureDescriptor &desc) override
ISize	GetMaxTextureSizeSupported () const override
void	DebugTraceMemoryStatistics () const override
	Write debug memory usage information to the dart timeline in debug and profile modes.

Friends
class	ContextVK

Additional Inherited Members
Protected Member Functions inherited from impeller::Allocator
	Allocator ()

Detailed Description

Definition at line 19 of file allocator_vk.h.

Constructor & Destructor Documentation

~AllocatorVK()

impeller::AllocatorVK::~AllocatorVK ( )

overridedefault

Member Function Documentation

DebugGetHeapUsage()

size_t impeller::AllocatorVK::DebugGetHeapUsage

(

)

const

Definition at line 512 of file allocator_vk.cc.

                                            {
  auto count = memory_properties_.memoryHeapCount;
  std::vector<VmaBudget> budgets(count);
  vmaGetHeapBudgets(allocator_.get(), budgets.data());
  size_t total_usage = 0;
  for (auto i = 0u; i < count; i++) {
    const VmaBudget& budget = budgets[i];
    total_usage += budget.usage;
  }
  // Convert bytes to MB.
  total_usage *= 1e-6;
  return total_usage;
}

DebugTraceMemoryStatistics()

void impeller::AllocatorVK::DebugTraceMemoryStatistics ( ) const

overrideprivatevirtual

Write debug memory usage information to the dart timeline in debug and profile modes.

This is only supported on the Vulkan backend.

Reimplemented from impeller::Allocator.

Definition at line 526 of file allocator_vk.cc.

                                                   {
#ifdef IMPELLER_DEBUG
  FML_TRACE_COUNTER("flutter", "AllocatorVK",
                    reinterpret_cast<int64_t>(this),  // Trace Counter ID
                    "MemoryBudgetUsageMB", DebugGetHeapUsage());
#endif  // IMPELLER_DEBUG
}

FindMemoryTypeIndex()

int32_t impeller::AllocatorVK::FindMemoryTypeIndex ( uint32_t  memory_type_bits_requirement, vk::PhysicalDeviceMemoryProperties &  memory_properties  )

static

Select a matching memory type for the given [memory_type_bits_requirement], or -1 if none is found.

This only returns memory types with deviceLocal allocations.

Definition at line 173 of file allocator_vk.cc.

                                                         {
  int32_t type_index = -1;
  vk::MemoryPropertyFlagBits required_properties =
      vk::MemoryPropertyFlagBits::eDeviceLocal;
 
  const uint32_t memory_count = memory_properties.memoryTypeCount;
  for (uint32_t memory_index = 0; memory_index < memory_count; ++memory_index) {
    const uint32_t memory_type_bits = (1 << memory_index);
    const bool is_required_memory_type =
        memory_type_bits_requirement & memory_type_bits;
 
    const auto properties =
        memory_properties.memoryTypes[memory_index].propertyFlags;
    const bool has_required_properties =
        (properties & required_properties) == required_properties;
 
    if (is_required_memory_type && has_required_properties) {
      return static_cast<int32_t>(memory_index);
    }
  }
 
  return type_index;
}

GetMaxTextureSizeSupported()

ISize impeller::AllocatorVK::GetMaxTextureSizeSupported ( ) const

overrideprivatevirtual

Implements impeller::Allocator.

Definition at line 169 of file allocator_vk.cc.

                                                    {
  return max_texture_size_;
}

OnCreateBuffer()

std::shared_ptr< DeviceBuffer > impeller::AllocatorVK::OnCreateBuffer ( const DeviceBufferDescriptor &  desc )

overrideprivatevirtual

Implements impeller::Allocator.

Definition at line 460 of file allocator_vk.cc.

                                        {
  vk::BufferCreateInfo buffer_info;
  buffer_info.usage = vk::BufferUsageFlagBits::eVertexBuffer |
                      vk::BufferUsageFlagBits::eIndexBuffer |
                      vk::BufferUsageFlagBits::eUniformBuffer |
                      vk::BufferUsageFlagBits::eStorageBuffer |
                      vk::BufferUsageFlagBits::eTransferSrc |
                      vk::BufferUsageFlagBits::eTransferDst;
  buffer_info.size = desc.size;
  buffer_info.sharingMode = vk::SharingMode::eExclusive;
  auto buffer_info_native =
      static_cast<vk::BufferCreateInfo::NativeType>(buffer_info);
 
  VmaAllocationCreateInfo allocation_info = {};
  allocation_info.usage = ToVMAMemoryUsage();
  allocation_info.preferredFlags = static_cast<VkMemoryPropertyFlags>(
      ToVKBufferMemoryPropertyFlags(desc.storage_mode));
  allocation_info.flags =
      ToVmaAllocationBufferCreateFlags(desc.storage_mode, desc.readback);
  if (created_buffer_pool_ && desc.storage_mode == StorageMode::kHostVisible &&
      !desc.readback) {
    allocation_info.pool = staging_buffer_pool_.get().pool;
  }
 
  VkBuffer buffer = {};
  VmaAllocation buffer_allocation = {};
  VmaAllocationInfo buffer_allocation_info = {};
  auto result = vk::Result{::vmaCreateBuffer(allocator_.get(),        //
                                             &buffer_info_native,     //
                                             &allocation_info,        //
                                             &buffer,                 //
                                             &buffer_allocation,      //
                                             &buffer_allocation_info  //
                                             )};
 
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Unable to allocate a device buffer: "
                   << vk::to_string(result);
    return {};
  }
 
  return std::make_shared<DeviceBufferVK>(
      desc,                                            //
      context_,                                        //
      UniqueBufferVMA{BufferVMA{allocator_.get(),      //
                                buffer_allocation,     //
                                vk::Buffer{buffer}}},  //
      buffer_allocation_info                           //
  );
}

OnCreateTexture()

std::shared_ptr< Texture > impeller::AllocatorVK::OnCreateTexture ( const TextureDescriptor &  desc )

overrideprivatevirtual

Implements impeller::Allocator.

Definition at line 433 of file allocator_vk.cc.

                                   {
  if (!IsValid()) {
    return nullptr;
  }
  auto device_holder = device_holder_.lock();
  if (!device_holder) {
    return nullptr;
  }
  auto context = context_.lock();
  if (!context) {
    return nullptr;
  }
  auto source = std::make_shared<AllocatedTextureSourceVK>(
      ContextVK::Cast(*context).GetResourceManager(),  //
      desc,                                            //
      allocator_.get(),                                //
      device_holder->GetDevice(),                      //
      supports_memoryless_textures_                    //
  );
  if (!source->IsValid()) {
    return nullptr;
  }
  return std::make_shared<TextureVK>(context_, std::move(source));
}

ToVKImageUsageFlags()

vk::ImageUsageFlags impeller::AllocatorVK::ToVKImageUsageFlags ( PixelFormat  format, TextureUsageMask  usage, StorageMode  mode, bool  supports_memoryless_textures  )

static

Definition at line 199 of file allocator_vk.cc.

                                       {
  vk::ImageUsageFlags vk_usage;
 
  switch (mode) {
    case StorageMode::kHostVisible:
    case StorageMode::kDevicePrivate:
      break;
    case StorageMode::kDeviceTransient:
      if (supports_memoryless_textures) {
        vk_usage |= vk::ImageUsageFlagBits::eTransientAttachment;
      }
      break;
  }
 
  if (usage & TextureUsage::kRenderTarget) {
    if (PixelFormatIsDepthStencil(format)) {
      vk_usage |= vk::ImageUsageFlagBits::eDepthStencilAttachment;
    } else {
      vk_usage |= vk::ImageUsageFlagBits::eColorAttachment;
      vk_usage |= vk::ImageUsageFlagBits::eInputAttachment;
    }
  }
 
  if (usage & TextureUsage::kShaderRead) {
    vk_usage |= vk::ImageUsageFlagBits::eSampled;
  }
 
  if (usage & TextureUsage::kShaderWrite) {
    vk_usage |= vk::ImageUsageFlagBits::eStorage;
  }
 
  if (mode != StorageMode::kDeviceTransient) {
    // Add transfer usage flags to support blit passes only if image isn't
    // device transient.
    vk_usage |= vk::ImageUsageFlagBits::eTransferSrc |
                vk::ImageUsageFlagBits::eTransferDst;
  }
 
  return vk_usage;
}

Friends And Related Symbol Documentation

ContextVK

friend class ContextVK

friend

Definition at line 43 of file allocator_vk.h.

---

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

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