impeller::PipelineCacheVK Class Reference

#include <pipeline_cache_vk.h>

Public Member Functions
	PipelineCacheVK (std::shared_ptr< const Capabilities > caps, std::shared_ptr< DeviceHolderVK > device_holder, fml::UniqueFD cache_directory)
	~PipelineCacheVK ()
bool	IsValid () const
vk::UniquePipeline	CreatePipeline (const vk::GraphicsPipelineCreateInfo &info)
vk::UniquePipeline	CreatePipeline (const vk::ComputePipelineCreateInfo &info)
const CapabilitiesVK *	GetCapabilities () const
void	PersistCacheToDisk ()

Detailed Description

Definition at line 15 of file pipeline_cache_vk.h.

Constructor & Destructor Documentation

PipelineCacheVK()

impeller::PipelineCacheVK::PipelineCacheVK ( std::shared_ptr< const Capabilities >  caps, std::shared_ptr< DeviceHolderVK >  device_holder, fml::UniqueFD  cache_directory  )

explicit

Definition at line 18 of file pipeline_cache_vk.cc.

    : caps_(std::move(caps)),
      device_holder_(device_holder),
      cache_directory_(std::move(cache_directory)) {
  if (!caps_ || !device_holder->GetDevice()) {
    return;
  }
 
  const auto& vk_caps = CapabilitiesVK::Cast(*caps_);
 
  auto existing_cache_data = PipelineCacheDataRetrieve(
      cache_directory_, vk_caps.GetPhysicalDeviceProperties());
 
  vk::PipelineCacheCreateInfo cache_info;
  if (existing_cache_data) {
    cache_info.initialDataSize = existing_cache_data->GetSize();
    cache_info.pInitialData = existing_cache_data->GetMapping();
  }
 
  auto [result, existing_cache] =
      device_holder->GetDevice().createPipelineCacheUnique(cache_info);
 
  if (result == vk::Result::eSuccess) {
    cache_ = std::move(existing_cache);
  } else {
    // Even though we perform consistency checks because we don't trust the
    // driver, the driver may have additional information that may cause it to
    // reject the cache too.
    FML_LOG(INFO) << "Existing pipeline cache was invalid: "
                  << vk::to_string(result) << ". Starting with a fresh cache.";
    cache_info.pInitialData = nullptr;
    cache_info.initialDataSize = 0u;
    auto [result2, new_cache] =
        device_holder->GetDevice().createPipelineCacheUnique(cache_info);
    if (result2 == vk::Result::eSuccess) {
      cache_ = std::move(new_cache);
    } else {
      VALIDATION_LOG << "Could not create new pipeline cache: "
                     << vk::to_string(result2);
    }
  }
 
  is_valid_ = !!cache_;
}

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), FML_LOG, impeller::PipelineCacheDataRetrieve(), and VALIDATION_LOG.

~PipelineCacheVK()

impeller::PipelineCacheVK::~PipelineCacheVK

(

)

Definition at line 65 of file pipeline_cache_vk.cc.

                                  {
  std::shared_ptr<DeviceHolderVK> device_holder = device_holder_.lock();
  if (device_holder) {
    cache_.reset();
  } else {
    cache_.release();
  }
}

Member Function Documentation

CreatePipeline() [1/2]

vk::UniquePipeline impeller::PipelineCacheVK::CreatePipeline

(

const vk::ComputePipelineCreateInfo &

info

)

Definition at line 94 of file pipeline_cache_vk.cc.

                                             {
  std::shared_ptr<DeviceHolderVK> strong_device = device_holder_.lock();
  if (!strong_device) {
    return {};
  }
 
  auto [result, pipeline] =
      strong_device->GetDevice().createComputePipelineUnique(*cache_, info);
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not create compute pipeline: "
                   << vk::to_string(result);
  }
  return std::move(pipeline);
}

References VALIDATION_LOG.

CreatePipeline() [2/2]

vk::UniquePipeline impeller::PipelineCacheVK::CreatePipeline

(

const vk::GraphicsPipelineCreateInfo &

info

)

Definition at line 78 of file pipeline_cache_vk.cc.

                                              {
  std::shared_ptr<DeviceHolderVK> strong_device = device_holder_.lock();
  if (!strong_device) {
    return {};
  }
 
  auto [result, pipeline] =
      strong_device->GetDevice().createGraphicsPipelineUnique(*cache_, info);
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not create graphics pipeline: "
                   << vk::to_string(result);
  }
  return std::move(pipeline);
}

References VALIDATION_LOG.

GetCapabilities()

const CapabilitiesVK * impeller::PipelineCacheVK::GetCapabilities

(

)

const

Definition at line 125 of file pipeline_cache_vk.cc.

                                                             {
  return CapabilitiesVK::Cast(caps_.get());
}

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast().

IsValid()

bool impeller::PipelineCacheVK::IsValid

(

)

const

Definition at line 74 of file pipeline_cache_vk.cc.

                                    {
  return is_valid_;
}

PersistCacheToDisk()

void impeller::PipelineCacheVK::PersistCacheToDisk

(

)

Definition at line 110 of file pipeline_cache_vk.cc.

                                         {
  // PersistCacheToDisk is run on a worker thread pool.  Calls to
  // PipelineCacheDataPersist should be serialized so that multiple worker
  // threads do not concurrently write to the cache file.
  Lock persist_lock(persist_mutex_);
  if (!is_valid_) {
    return;
  }
  const auto& vk_caps = CapabilitiesVK::Cast(*caps_);
  PipelineCacheDataPersist(cache_directory_,                       //
                           vk_caps.GetPhysicalDeviceProperties(),  //
                           cache_                                  //
  );
}

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), and impeller::PipelineCacheDataPersist().

---

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

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