#include <vulkan_surface_pool.h>

Public Member Functions
	VulkanSurfacePool (vulkan::VulkanProvider &vulkan_provider, sk_sp< GrDirectContext > context)

	~VulkanSurfacePool ()

std::unique_ptr< VulkanSurface >	CreateSurface (const SkISize &size)

std::unique_ptr< VulkanSurface >	AcquireSurface (const SkISize &size)

void	SubmitSurface (std::unique_ptr< SurfaceProducerSurface > surface)

void	AgeAndCollectOldBuffers ()

void	ShrinkToFit ()

Static Public Attributes
static constexpr int	kMaxSurfaces = 12

static constexpr int	kMaxSurfaceAge = 3

Detailed Description

Definition at line 18 of file vulkan_surface_pool.h.

Constructor & Destructor Documentation

◆ VulkanSurfacePool()

flutter_runner::VulkanSurfacePool::VulkanSurfacePool	(	vulkan::VulkanProvider &	vulkan_provider,
		sk_sp< GrDirectContext >	context
	)

Definition at line 32 of file vulkan_surface_pool.cc.

    : vulkan_provider_(vulkan_provider), context_(std::move(context)) {
  FML_CHECK(context_ != nullptr);
 
  zx_status_t status = fdio_service_connect(
      "/svc/fuchsia.sysmem.Allocator",
      sysmem_allocator_.NewRequest().TakeChannel().release());
  sysmem_allocator_->SetDebugClientInfo(GetCurrentProcessName(),
                                        GetCurrentProcessId());
  FML_DCHECK(status == ZX_OK);
 
  status = fdio_service_connect(
      "/svc/fuchsia.ui.composition.Allocator",
      flatland_allocator_.NewRequest().TakeChannel().release());
  FML_DCHECK(status == ZX_OK);
}

◆ ~VulkanSurfacePool()

flutter_runner::VulkanSurfacePool::~VulkanSurfacePool ( )

Definition at line 50 of file vulkan_surface_pool.cc.

50{}

Member Function Documentation

◆ AcquireSurface()

std::unique_ptr< VulkanSurface > flutter_runner::VulkanSurfacePool::AcquireSurface ( const SkISize & size )

Definition at line 52 of file vulkan_surface_pool.cc.

                         {
  auto surface = GetCachedOrCreateSurface(size);
 
  if (surface == nullptr) {
    FML_LOG(ERROR) << "VulkanSurfaceProducer: Could not acquire surface";
    return nullptr;
  }
 
  if (!surface->FlushSessionAcquireAndReleaseEvents()) {
    FML_LOG(ERROR) << "VulkanSurfaceProducer: Could not flush acquire/release "
                      "events for buffer.";
    return nullptr;
  }
 
  return surface;
}

◆ AgeAndCollectOldBuffers()

void flutter_runner::VulkanSurfacePool::AgeAndCollectOldBuffers ( )

Definition at line 165 of file vulkan_surface_pool.cc.

                                                {
  TRACE_EVENT0("flutter", "VulkanSurfacePool::AgeAndCollectOldBuffers");
 
  // Remove all surfaces that are no longer valid or are too old.
  size_t size_before = available_surfaces_.size();
  available_surfaces_.erase(
      std::remove_if(available_surfaces_.begin(), available_surfaces_.end(),
                     [&](auto& surface) {
                       return !surface->IsValid() ||
                              surface->AdvanceAndGetAge() >= kMaxSurfaceAge;
                     }),
      available_surfaces_.end());
  TRACE_EVENT1("flutter", "AgeAndCollect", "aged surfaces",
               (size_before - available_surfaces_.size()));
 
  // Look for a surface that has both a larger |VkDeviceMemory| allocation
  // than is necessary for its |VkImage|, and has a stable size history.
  auto surface_to_remove_it = std::find_if(
      available_surfaces_.begin(), available_surfaces_.end(),
      [](const auto& surface) {
        return surface->IsOversized() && surface->HasStableSizeHistory();
      });
  // If we found such a surface, then destroy it and cache a new one that only
  // uses a necessary amount of memory.
  if (surface_to_remove_it != available_surfaces_.end()) {
    TRACE_EVENT_INSTANT0("flutter", "replacing surface with smaller one");
    auto size = (*surface_to_remove_it)->GetSize();
    available_surfaces_.erase(surface_to_remove_it);
    auto new_surface = CreateSurface(size);
    if (new_surface != nullptr) {
      available_surfaces_.push_back(std::move(new_surface));
    } else {
      FML_LOG(ERROR)
          << "VulkanSurfaceProducer: Failed to create a new shrunk surface";
    }
  }
 
  TraceStats();
}

◆ CreateSurface()

std::unique_ptr< VulkanSurface > flutter_runner::VulkanSurfacePool::CreateSurface ( const SkISize & size )

Definition at line 117 of file vulkan_surface_pool.cc.

                         {
  TRACE_EVENT2("flutter", "VulkanSurfacePool::CreateSurface", "width",
               size.width(), "height", size.height());
  auto surface = std::make_unique<VulkanSurface>(
      vulkan_provider_, sysmem_allocator_, flatland_allocator_, context_, size);
  if (!surface->IsValid()) {
    FML_LOG(ERROR) << "VulkanSurfaceProducer: Created surface is invalid";
    return nullptr;
  }
  trace_surfaces_created_++;
  return surface;
}

◆ ShrinkToFit()

void flutter_runner::VulkanSurfacePool::ShrinkToFit ( )

Definition at line 205 of file vulkan_surface_pool.cc.

                                    {
  TRACE_EVENT0("flutter", "VulkanSurfacePool::ShrinkToFit");
  // Reset all oversized surfaces in |available_surfaces_| so that the old
  // surfaces and new surfaces don't exist at the same time at any point,
  // reducing our peak memory footprint.
  std::vector<SkISize> sizes_to_recreate;
  for (auto& surface : available_surfaces_) {
    if (surface->IsOversized()) {
      sizes_to_recreate.push_back(surface->GetSize());
      surface.reset();
    }
  }
  available_surfaces_.erase(std::remove(available_surfaces_.begin(),
                                        available_surfaces_.end(), nullptr),
                            available_surfaces_.end());
  for (const auto& size : sizes_to_recreate) {
    auto surface = CreateSurface(size);
    if (surface != nullptr) {
      available_surfaces_.push_back(std::move(surface));
    } else {
      FML_LOG(ERROR)
          << "VulkanSurfaceProducer: Failed to create resized surface";
    }
  }
 
  TraceStats();
}

◆ SubmitSurface()

void flutter_runner::VulkanSurfacePool::SubmitSurface ( std::unique_ptr< SurfaceProducerSurface > surface )

Definition at line 92 of file vulkan_surface_pool.cc.

                                                     {
  TRACE_EVENT0("flutter", "VulkanSurfacePool::SubmitSurface");
 
  // This cast is safe because |VulkanSurface| is the only implementation of
  // |SurfaceProducerSurface| for Flutter on Fuchsia.  Additionally, it is
  // required, because we need to access |VulkanSurface| specific information
  // of the surface (such as the amount of VkDeviceMemory it contains).
  auto vulkan_surface = std::unique_ptr<VulkanSurface>(
      static_cast<VulkanSurface*>(p_surface.release()));
  if (!vulkan_surface) {
    return;
  }
 
  uintptr_t surface_key = reinterpret_cast<uintptr_t>(vulkan_surface.get());
  auto insert_iterator = pending_surfaces_.insert(std::make_pair(
      surface_key,               // key
      std::move(vulkan_surface)  // value
      ));
  if (insert_iterator.second) {
    insert_iterator.first->second->SignalWritesFinished(std::bind(
        &VulkanSurfacePool::RecyclePendingSurface, this, surface_key));
  }
}

Member Data Documentation

◆ kMaxSurfaceAge

constexpr int flutter_runner::VulkanSurfacePool::kMaxSurfaceAge = 3

staticconstexpr

Definition at line 24 of file vulkan_surface_pool.h.

◆ kMaxSurfaces

constexpr int flutter_runner::VulkanSurfacePool::kMaxSurfaces = 12