9 #include "flutter/fml/container.h"
10 #include "flutter/fml/trace_event.h"
20 PipelineLibraryVK::PipelineLibraryVK(
21 const std::shared_ptr<DeviceHolderVK>& device_holder,
22 std::shared_ptr<const Capabilities> caps,
23 fml::UniqueFD cache_directory,
24 std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner)
25 : device_holder_(device_holder),
26 pso_cache_(
std::make_shared<PipelineCacheVK>(
std::move(caps),
28 std::move(cache_directory))),
29 worker_task_runner_(
std::move(worker_task_runner)) {
30 FML_DCHECK(worker_task_runner_);
31 if (!pso_cache_->IsValid() || !worker_task_runner_) {
38 PipelineLibraryVK::~PipelineLibraryVK() =
default;
41 bool PipelineLibraryVK::IsValid()
const {
45 std::unique_ptr<ComputePipelineVK> PipelineLibraryVK::CreateComputePipeline(
46 const ComputePipelineDescriptor& desc,
48 TRACE_EVENT0(
"flutter", __FUNCTION__);
49 vk::ComputePipelineCreateInfo pipeline_info;
54 const auto entrypoint = desc.GetStageEntrypoint();
60 std::shared_ptr<DeviceHolderVK> strong_device = device_holder_.lock();
64 auto device_properties = strong_device->GetPhysicalDevice().getProperties();
65 auto max_wg_size = device_properties.limits.maxComputeWorkGroupSize;
69 vk::SpecializationMapEntry specialization_map_entry[1];
71 uint32_t workgroup_size_x = max_wg_size[0];
72 specialization_map_entry[0].constantID = 0;
73 specialization_map_entry[0].offset = 0;
74 specialization_map_entry[0].size =
sizeof(uint32_t);
76 vk::SpecializationInfo specialization_info;
77 specialization_info.mapEntryCount = 1;
78 specialization_info.pMapEntries = &specialization_map_entry[0];
79 specialization_info.dataSize =
sizeof(uint32_t);
80 specialization_info.pData = &workgroup_size_x;
82 vk::PipelineShaderStageCreateInfo info;
83 info.setStage(vk::ShaderStageFlagBits::eCompute);
84 info.setPName(
"main");
85 info.setModule(ShaderFunctionVK::Cast(entrypoint.get())->GetModule());
86 info.setPSpecializationInfo(&specialization_info);
87 pipeline_info.setStage(info);
92 std::vector<vk::DescriptorSetLayoutBinding> desc_bindings;
94 for (
auto layout : desc.GetDescriptorSetLayouts()) {
96 desc_bindings.push_back(vk_desc_layout);
99 vk::DescriptorSetLayoutCreateInfo descs_layout_info;
100 descs_layout_info.setBindings(desc_bindings);
102 auto [descs_result, descs_layout] =
103 strong_device->GetDevice().createDescriptorSetLayoutUnique(
105 if (descs_result != vk::Result::eSuccess) {
110 ContextVK::SetDebugName(strong_device->GetDevice(), descs_layout.get(),
111 "Descriptor Set Layout " + desc.GetLabel());
116 vk::PipelineLayoutCreateInfo pipeline_layout_info;
117 pipeline_layout_info.setSetLayouts(descs_layout.get());
118 auto pipeline_layout = strong_device->GetDevice().createPipelineLayoutUnique(
119 pipeline_layout_info);
120 if (pipeline_layout.result != vk::Result::eSuccess) {
121 VALIDATION_LOG <<
"Could not create pipeline layout for pipeline "
122 << desc.GetLabel() <<
": "
123 << vk::to_string(pipeline_layout.result);
126 pipeline_info.setLayout(pipeline_layout.value.get());
131 auto pipeline = pso_cache_->CreatePipeline(pipeline_info);
133 VALIDATION_LOG <<
"Could not create graphics pipeline: " << desc.GetLabel();
137 ContextVK::SetDebugName(strong_device->GetDevice(), *pipeline_layout.value,
138 "Pipeline Layout " + desc.GetLabel());
139 ContextVK::SetDebugName(strong_device->GetDevice(), *pipeline,
140 "Pipeline " + desc.GetLabel());
142 return std::make_unique<ComputePipelineVK>(
147 std::move(pipeline_layout.value),
148 std::move(descs_layout),
153 PipelineFuture<PipelineDescriptor> PipelineLibraryVK::GetPipeline(
154 PipelineDescriptor descriptor,
156 Lock lock(pipelines_mutex_);
158 return found->second;
165 RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(
nullptr)};
168 auto promise = std::make_shared<
169 NoExceptionPromise<std::shared_ptr<Pipeline<PipelineDescriptor>>>>();
170 auto pipeline_future =
171 PipelineFuture<PipelineDescriptor>{descriptor, promise->get_future()};
174 auto weak_this = weak_from_this();
177 auto generation_task = [descriptor, weak_this, promise, next_key]() {
178 auto thiz = weak_this.lock();
180 promise->set_value(
nullptr);
181 VALIDATION_LOG <<
"Pipeline library was collected before the pipeline "
188 PipelineLibraryVK::Cast(*thiz).device_holder_.lock(),
195 worker_task_runner_->PostTask(generation_task);
200 return pipeline_future;
204 PipelineFuture<ComputePipelineDescriptor> PipelineLibraryVK::GetPipeline(
205 ComputePipelineDescriptor descriptor,
207 Lock lock(pipelines_mutex_);
208 if (
auto found = compute_pipelines_.find(descriptor);
209 found != compute_pipelines_.end()) {
210 return found->second;
217 RealizedFuture<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>(
221 auto promise = std::make_shared<
222 std::promise<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>>();
223 auto pipeline_future = PipelineFuture<ComputePipelineDescriptor>{
224 descriptor, promise->get_future()};
225 compute_pipelines_[descriptor] = pipeline_future;
227 auto weak_this = weak_from_this();
230 auto generation_task = [descriptor, weak_this, promise, next_key]() {
231 auto self = weak_this.lock();
233 promise->set_value(
nullptr);
234 VALIDATION_LOG <<
"Pipeline library was collected before the pipeline "
239 auto pipeline = PipelineLibraryVK::Cast(*self).CreateComputePipeline(
240 descriptor, next_key);
242 promise->set_value(
nullptr);
243 VALIDATION_LOG <<
"Could not create pipeline: " << descriptor.GetLabel();
247 promise->set_value(std::move(pipeline));
251 worker_task_runner_->PostTask(generation_task);
256 return pipeline_future;
260 bool PipelineLibraryVK::HasPipeline(
const PipelineDescriptor& descriptor) {
261 Lock lock(pipelines_mutex_);
266 void PipelineLibraryVK::RemovePipelinesWithEntryPoint(
267 std::shared_ptr<const ShaderFunction>
function) {
268 Lock lock(pipelines_mutex_);
271 return item->first.GetEntrypointForStage(function->GetStage())
272 ->IsEqual(*
function);
276 void PipelineLibraryVK::DidAcquireSurfaceFrame() {
277 if (++frames_acquired_ == 50u) {
279 cache_dirty_ =
false;
280 PersistPipelineCacheToDisk();
282 frames_acquired_ = 0;
286 void PipelineLibraryVK::PersistPipelineCacheToDisk() {
287 worker_task_runner_->PostTask(
288 [weak_cache = decltype(pso_cache_)::weak_type(pso_cache_)]() {
289 auto cache = weak_cache.lock();
293 cache->PersistCacheToDisk();
297 const std::shared_ptr<PipelineCacheVK>& PipelineLibraryVK::GetPSOCache()
const {
301 const std::shared_ptr<fml::ConcurrentTaskRunner>&
302 PipelineLibraryVK::GetWorkerTaskRunner()
const {
303 return worker_task_runner_;
std::vector< std::pair< uint64_t, std::unique_ptr< GenericRenderPipelineHandle > > > pipelines_
ScopedObject< Object > Create(CtorArgs &&... args)
constexpr vk::DescriptorSetLayoutBinding ToVKDescriptorSetLayoutBinding(const DescriptorSetLayout &layout)