blob: ff15cba295f6a1544cd5fb2380ba9a736073e6c6 [file] [log] [blame]
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrVkResourceProvider_DEFINED
#define GrVkResourceProvider_DEFINED
#include "include/gpu/vk/GrVkTypes.h"
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkTArray.h"
#include "src/core/SkLRUCache.h"
#include "src/core/SkTDynamicHash.h"
#include "src/core/SkTInternalLList.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrManagedResource.h"
#include "src/gpu/ganesh/GrProgramDesc.h"
#include "src/gpu/ganesh/GrResourceHandle.h"
#include "src/gpu/ganesh/GrThreadSafePipelineBuilder.h"
#include "src/gpu/ganesh/vk/GrVkDescriptorPool.h"
#include "src/gpu/ganesh/vk/GrVkDescriptorSetManager.h"
#include "src/gpu/ganesh/vk/GrVkPipelineStateBuilder.h"
#include "src/gpu/ganesh/vk/GrVkRenderPass.h"
#include "src/gpu/ganesh/vk/GrVkSampler.h"
#include "src/gpu/ganesh/vk/GrVkSamplerYcbcrConversion.h"
#include "src/gpu/ganesh/vk/GrVkUtil.h"
class GrVkCommandPool;
class GrVkGpu;
class GrVkPipeline;
class GrVkPipelineState;
class GrVkPrimaryCommandBuffer;
class GrVkRenderTarget;
class GrVkSecondaryCommandBuffer;
class GrVkUniformHandler;
class GrVkResourceProvider {
public:
GrVkResourceProvider(GrVkGpu* gpu);
~GrVkResourceProvider();
GrThreadSafePipelineBuilder* pipelineStateCache() {
return fPipelineStateCache.get();
}
sk_sp<GrThreadSafePipelineBuilder> refPipelineStateCache() {
return fPipelineStateCache;
}
// Set up any initial vk objects
void init();
sk_sp<const GrVkPipeline> makePipeline(const GrProgramInfo&,
VkPipelineShaderStageCreateInfo* shaderStageInfo,
int shaderStageCount,
VkRenderPass compatibleRenderPass,
VkPipelineLayout layout,
uint32_t subpass);
GR_DEFINE_RESOURCE_HANDLE_CLASS(CompatibleRPHandle);
using SelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags;
using LoadFromResolve = GrVkRenderPass::LoadFromResolve;
// Finds or creates a simple render pass that matches the target, increments the refcount,
// and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle. If this is
// non null it will be set to a handle that can be used in the furutre to quickly return a
// compatible GrVkRenderPasses without the need inspecting a GrVkRenderTarget.
const GrVkRenderPass* findCompatibleRenderPass(GrVkRenderTarget* target,
CompatibleRPHandle* compatibleHandle,
bool withResolve,
bool withStencil,
SelfDependencyFlags selfDepFlags,
LoadFromResolve);
const GrVkRenderPass* findCompatibleRenderPass(GrVkRenderPass::AttachmentsDescriptor*,
GrVkRenderPass::AttachmentFlags,
SelfDependencyFlags selfDepFlags,
LoadFromResolve,
CompatibleRPHandle* compatibleHandle = nullptr);
const GrVkRenderPass* findCompatibleExternalRenderPass(VkRenderPass,
uint32_t colorAttachmentIndex);
// Finds or creates a render pass that matches the target and LoadStoreOps, increments the
// refcount, and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle.
// If this is non null it will be set to a handle that can be used in the future to quickly
// return a GrVkRenderPass without the need to inspect a GrVkRenderTarget.
// TODO: sk_sp?
const GrVkRenderPass* findRenderPass(GrVkRenderTarget* target,
const GrVkRenderPass::LoadStoreOps& colorOps,
const GrVkRenderPass::LoadStoreOps& resolveOps,
const GrVkRenderPass::LoadStoreOps& stencilOps,
CompatibleRPHandle* compatibleHandle,
bool withResolve,
bool withStencil,
SelfDependencyFlags selfDepFlags,
LoadFromResolve);
// The CompatibleRPHandle must be a valid handle previously set by a call to findRenderPass or
// findCompatibleRenderPass.
const GrVkRenderPass* findRenderPass(const CompatibleRPHandle& compatibleHandle,
const GrVkRenderPass::LoadStoreOps& colorOps,
const GrVkRenderPass::LoadStoreOps& resolveOps,
const GrVkRenderPass::LoadStoreOps& stencilOps);
GrVkCommandPool* findOrCreateCommandPool();
void checkCommandBuffers();
void forceSyncAllCommandBuffers();
// We must add the finishedProc to all active command buffers since we may have flushed work
// that the client cares about before they explicitly called flush and the GPU may reorder
// command execution. So we make sure all previously submitted work finishes before we call the
// finishedProc.
void addFinishedProcToActiveCommandBuffers(sk_sp<skgpu::RefCntedCallback> finishedCallback);
// Finds or creates a compatible GrVkDescriptorPool for the requested type and count.
// The refcount is incremented and a pointer returned.
// TODO: Currently this will just create a descriptor pool without holding onto a ref itself
// so we currently do not reuse them. Rquires knowing if another draw is currently using
// the GrVkDescriptorPool, the ability to reset pools, and the ability to purge pools out
// of our cache of GrVkDescriptorPools.
GrVkDescriptorPool* findOrCreateCompatibleDescriptorPool(VkDescriptorType type, uint32_t count);
// Finds or creates a compatible GrVkSampler based on the GrSamplerState and
// GrVkYcbcrConversionInfo. The refcount is incremented and a pointer returned.
GrVkSampler* findOrCreateCompatibleSampler(GrSamplerState,
const GrVkYcbcrConversionInfo& ycbcrInfo);
// Finds or creates a compatible GrVkSamplerYcbcrConversion based on the GrSamplerState and
// GrVkYcbcrConversionInfo. The refcount is incremented and a pointer returned.
GrVkSamplerYcbcrConversion* findOrCreateCompatibleSamplerYcbcrConversion(
const GrVkYcbcrConversionInfo& ycbcrInfo);
GrVkPipelineState* findOrCreateCompatiblePipelineState(
GrRenderTarget*,
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad);
GrVkPipelineState* findOrCreateCompatiblePipelineState(
const GrProgramDesc&,
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
GrThreadSafePipelineBuilder::Stats::ProgramCacheResult* stat);
sk_sp<const GrVkPipeline> findOrCreateMSAALoadPipeline(
const GrVkRenderPass& renderPass,
int numSamples,
VkPipelineShaderStageCreateInfo*,
VkPipelineLayout);
void getSamplerDescriptorSetHandle(VkDescriptorType type,
const GrVkUniformHandler&,
GrVkDescriptorSetManager::Handle* handle);
// This is a convenience function to return a descriptor set for zero sammples. When making a
// VkPipelineLayout we must pass in an array of valid descriptor set handles. However, we have
// set up our system to have the descriptor sets be in the order uniform, sampler, input. So
// if we have a uniform and input we will need to have a valid handle for the sampler as well.
// When using the GrVkMSAALoadManager this is the case, but we also don't have a
// GrVkUniformHandler to pass into the more general function. Thus we use this call instead.
void getZeroSamplerDescriptorSetHandle(GrVkDescriptorSetManager::Handle* handle);
// Returns the compatible VkDescriptorSetLayout to use for uniform buffers. The caller does not
// own the VkDescriptorSetLayout and thus should not delete it. This function should be used
// when the caller needs the layout to create a VkPipelineLayout.
VkDescriptorSetLayout getUniformDSLayout() const;
// Returns the compatible VkDescriptorSetLayout to use for input attachments. The caller does
// not own the VkDescriptorSetLayout and thus should not delete it. This function should be used
// when the caller needs the layout to create a VkPipelineLayout.
VkDescriptorSetLayout getInputDSLayout() const;
// Returns the compatible VkDescriptorSetLayout to use for a specific sampler handle. The caller
// does not own the VkDescriptorSetLayout and thus should not delete it. This function should be
// used when the caller needs the layout to create a VkPipelineLayout.
VkDescriptorSetLayout getSamplerDSLayout(const GrVkDescriptorSetManager::Handle&) const;
// Returns a GrVkDescriptorSet that can be used for uniform buffers. The GrVkDescriptorSet
// is already reffed for the caller.
const GrVkDescriptorSet* getUniformDescriptorSet();
// Returns a GrVkDescriptorSet that can be used for sampler descriptors that are compatible with
// the GrVkDescriptorSetManager::Handle passed in. The GrVkDescriptorSet is already reffed for
// the caller.
const GrVkDescriptorSet* getSamplerDescriptorSet(const GrVkDescriptorSetManager::Handle&);
// Returns a GrVkDescriptorSet that can be used for input attachments. The GrVkDescriptorSet
// is already reffed for the caller.
const GrVkDescriptorSet* getInputDescriptorSet();
// Signals that the descriptor set passed it, which is compatible with the passed in handle,
// can be reused by the next allocation request.
void recycleDescriptorSet(const GrVkDescriptorSet* descSet,
const GrVkDescriptorSetManager::Handle&);
void storePipelineCacheData();
// Destroy any cached resources. To be called before destroying the VkDevice.
// The assumption is that all queues are idle and all command buffers are finished.
// For resource tracing to work properly, this should be called after unrefing all other
// resource usages.
void destroyResources();
// Currently we just release available command pools (which also releases their buffers). The
// command buffers and pools take up the most memory. Other objects (e.g. samples,
// ycbcr conversions, etc.) tend to be fairly light weight and not worth the effort to remove
// them and then possibly remake them. Additionally many of those objects have refs/handles that
// are held by other objects that aren't deleted here. Thus the memory wins for removing these
// objects from the cache are probably not worth the complexity of safely releasing them.
void releaseUnlockedBackendObjects();
#if GR_TEST_UTILS
void resetShaderCacheForTesting() const { fPipelineStateCache->release(); }
#endif
private:
class PipelineStateCache : public GrThreadSafePipelineBuilder {
public:
PipelineStateCache(GrVkGpu* gpu);
~PipelineStateCache() override;
void release();
GrVkPipelineState* findOrCreatePipelineState(GrRenderTarget*,
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad);
GrVkPipelineState* findOrCreatePipelineState(const GrProgramDesc& desc,
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass,
Stats::ProgramCacheResult* stat) {
return this->findOrCreatePipelineStateImpl(desc, programInfo, compatibleRenderPass,
false, stat);
}
private:
struct Entry;
GrVkPipelineState* findOrCreatePipelineStateImpl(const GrProgramDesc&,
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad,
Stats::ProgramCacheResult*);
struct DescHash {
uint32_t operator()(const GrProgramDesc& desc) const {
return SkOpts::hash_fn(desc.asKey(), desc.keyLength(), 0);
}
};
SkLRUCache<const GrProgramDesc, std::unique_ptr<Entry>, DescHash> fMap;
GrVkGpu* fGpu;
};
class CompatibleRenderPassSet {
public:
// This will always construct the basic load store render pass (all attachments load and
// store their data) so that there is at least one compatible VkRenderPass that can be used
// with this set.
CompatibleRenderPassSet(GrVkRenderPass* renderPass);
bool isCompatible(const GrVkRenderPass::AttachmentsDescriptor&,
GrVkRenderPass::AttachmentFlags,
SelfDependencyFlags selfDepFlags,
LoadFromResolve) const;
const GrVkRenderPass* getCompatibleRenderPass() const {
// The first GrVkRenderpass should always exist since we create the basic load store
// render pass on create
SkASSERT(fRenderPasses[0]);
return fRenderPasses[0];
}
GrVkRenderPass* getRenderPass(GrVkGpu* gpu,
const GrVkRenderPass::LoadStoreOps& colorOps,
const GrVkRenderPass::LoadStoreOps& resolveOps,
const GrVkRenderPass::LoadStoreOps& stencilOps);
void releaseResources();
private:
SkSTArray<4, GrVkRenderPass*> fRenderPasses;
int fLastReturnedIndex;
};
VkPipelineCache pipelineCache();
GrVkGpu* fGpu;
// Central cache for creating pipelines
VkPipelineCache fPipelineCache;
struct MSAALoadPipeline {
sk_sp<const GrVkPipeline> fPipeline;
const GrVkRenderPass* fRenderPass;
};
// Cache of previously created msaa load pipelines
SkTArray<MSAALoadPipeline> fMSAALoadPipelines;
SkSTArray<4, CompatibleRenderPassSet> fRenderPassArray;
SkTArray<const GrVkRenderPass*> fExternalRenderPasses;
// Array of command pools that we are waiting on
SkSTArray<4, GrVkCommandPool*, true> fActiveCommandPools;
// Array of available command pools that are not in flight
SkSTArray<4, GrVkCommandPool*, true> fAvailableCommandPools;
// Stores GrVkSampler objects that we've already created so we can reuse them across multiple
// GrVkPipelineStates
SkTDynamicHash<GrVkSampler, GrVkSampler::Key> fSamplers;
// Stores GrVkSamplerYcbcrConversion objects that we've already created so we can reuse them.
SkTDynamicHash<GrVkSamplerYcbcrConversion, GrVkSamplerYcbcrConversion::Key> fYcbcrConversions;
// Cache of GrVkPipelineStates
sk_sp<PipelineStateCache> fPipelineStateCache;
SkSTArray<4, std::unique_ptr<GrVkDescriptorSetManager>> fDescriptorSetManagers;
GrVkDescriptorSetManager::Handle fUniformDSHandle;
GrVkDescriptorSetManager::Handle fInputDSHandle;
};
#endif