src/gpu/vk/GrVkResourceProvider.h - platform/external/skia - Gitiles

 /*
 * 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 "GrGpu.h"
 #include "GrResourceHandle.h"
 #include "GrVkDescriptorPool.h"
 #include "GrVkDescriptorSetManager.h"
 #include "GrVkPipelineState.h"
 #include "GrVkRenderPass.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
 #include "SkTDynamicHash.h"
 #include "SkTHash.h"
 #include "SkTInternalLList.h"

 #include "vk/GrVkDefines.h"

 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrTextureParams;
 class GrVkCopyPipeline;
 class GrVkGpu;
 class GrVkPipeline;
 class GrVkPrimaryCommandBuffer;
 class GrVkRenderTarget;
 class GrVkSampler;
 class GrVkSecondaryCommandBuffer;
 class GrVkUniformHandler;

 class GrVkResourceProvider {
 public:
     GrVkResourceProvider(GrVkGpu* gpu);
     ~GrVkResourceProvider();

     // Set up any initial vk objects
     void init();

     GrVkPipeline* createPipeline(const GrPipeline& pipeline,
                                  const GrStencilSettings& stencil,
                                  const GrPrimitiveProcessor& primProc,
                                  VkPipelineShaderStageCreateInfo* shaderStageInfo,
                                  int shaderStageCount,
                                  GrPrimitiveType primitiveType,
                                  const GrVkRenderPass& renderPass,
                                  VkPipelineLayout layout);

     GrVkCopyPipeline* findOrCreateCopyPipeline(const GrVkRenderTarget* dst,
                                                VkPipelineShaderStageCreateInfo*,
                                                VkPipelineLayout);

     GR_DEFINE_RESOURCE_HANDLE_CLASS(CompatibleRPHandle);

     // 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(const GrVkRenderTarget& target,
                                                    CompatibleRPHandle* compatibleHandle = nullptr);
     // The CompatibleRPHandle must be a valid handle previously set by a call to
     // findCompatibleRenderPass(GrVkRenderTarget&, CompatibleRPHandle*).
     const GrVkRenderPass* findCompatibleRenderPass(const CompatibleRPHandle& compatibleHandle);

     // 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 furutre to quickly
     // return a GrVkRenderPasses without the need inspecting a GrVkRenderTarget.
     const GrVkRenderPass* findRenderPass(const GrVkRenderTarget& target,
                                          const GrVkRenderPass::LoadStoreOps& colorOps,
                                          const GrVkRenderPass::LoadStoreOps& stencilOps,
                                          CompatibleRPHandle* compatibleHandle = nullptr);

     // 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& stencilOps);

     GrVkPrimaryCommandBuffer* findOrCreatePrimaryCommandBuffer();
     void checkCommandBuffers();

     GrVkSecondaryCommandBuffer* findOrCreateSecondaryCommandBuffer();
     void recycleSecondaryCommandBuffer(GrVkSecondaryCommandBuffer* cb);

     // 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 GrTextureParams.
     // The refcount is incremented and a pointer returned.
     GrVkSampler* findOrCreateCompatibleSampler(const GrTextureParams&, uint32_t mipLevels);

     sk_sp<GrVkPipelineState> findOrCreateCompatiblePipelineState(const GrPipeline&,
                                                                  const GrPrimitiveProcessor&,
                                                                  GrPrimitiveType,
                                                                  const GrVkRenderPass& renderPass);

     void getSamplerDescriptorSetHandle(const GrVkUniformHandler&,
                                        GrVkDescriptorSetManager::Handle* handle);
     void getSamplerDescriptorSetHandle(const SkTArray<uint32_t>& visibilities,
                                        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 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&);


     // 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&);

     // Creates or finds free uniform buffer resources of size GrVkUniformBuffer::kStandardSize.
     // Anything larger will need to be created and released by the client.
     const GrVkResource* findOrCreateStandardUniformBufferResource();

     // Signals that the resource passed to it (which should be a uniform buffer resource)
     // can be reused by the next uniform buffer resource request.
     void recycleStandardUniformBufferResource(const GrVkResource*);

     // 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.
     // If deviceLost is true, then resources will not be checked to see if they've finished
     // before deleting (see section 4.2.4 of the Vulkan spec).
     void destroyResources(bool deviceLost);

     // Abandon any cached resources. To be used when the context/VkDevice is lost.
     // For resource tracing to work properly, this should be called after unrefing all other
     // resource usages.
     void abandonResources();

 private:
 #ifdef SK_DEBUG
 #define GR_PIPELINE_STATE_CACHE_STATS
 #endif

     class PipelineStateCache : public ::SkNoncopyable {
     public:
         PipelineStateCache(GrVkGpu* gpu);
         ~PipelineStateCache();

         void abandon();
         void release();
         sk_sp<GrVkPipelineState> refPipelineState(const GrPipeline&,
                                                   const GrPrimitiveProcessor&,
                                                   GrPrimitiveType,
                                                   const GrVkRenderPass& renderPass);

     private:
         enum {
             // We may actually have kMaxEntries+1 PipelineStates in context because we create a new
             // PipelineState before evicting from the cache.
             kMaxEntries = 128,
         };

         struct Entry;

         void reset();

         int                         fCount;
         SkTHashTable<Entry*, const GrVkPipelineState::Desc&, Entry> fHashTable;
         SkTInternalLList<Entry> fLRUList;

         GrVkGpu*                    fGpu;

 #ifdef GR_PIPELINE_STATE_CACHE_STATS
         int                         fTotalRequests;
         int                         fCacheMisses;
 #endif
     };

     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(const GrVkGpu* gpu, const GrVkRenderTarget& target);

         bool isCompatible(const GrVkRenderTarget& target) 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(const GrVkGpu* gpu,
                                       const GrVkRenderPass::LoadStoreOps& colorOps,
                                       const GrVkRenderPass::LoadStoreOps& stencilOps);

         void releaseResources(const GrVkGpu* gpu);
         void abandonResources();

     private:
         SkSTArray<4, GrVkRenderPass*> fRenderPasses;
         int                           fLastReturnedIndex;
     };

     GrVkGpu* fGpu;

     // Central cache for creating pipelines
     VkPipelineCache fPipelineCache;

     // Cache of previously created copy pipelines
     SkTArray<GrVkCopyPipeline*> fCopyPipelines;

     SkSTArray<4, CompatibleRenderPassSet> fRenderPassArray;

     // Array of PrimaryCommandBuffers that are currently in flight
     SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fActiveCommandBuffers;
     // Array of available primary command buffers that are not in flight
     SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fAvailableCommandBuffers;

     // Array of available secondary command buffers
     SkSTArray<16, GrVkSecondaryCommandBuffer*, true> fAvailableSecondaryCommandBuffers;

     // Array of available uniform buffer resources
     SkSTArray<16, const GrVkResource*, true> fAvailableUniformBufferResources;

     // Stores GrVkSampler objects that we've already created so we can reuse them across multiple
     // GrVkPipelineStates
     SkTDynamicHash<GrVkSampler, uint16_t> fSamplers;

     // Cache of GrVkPipelineStates
     PipelineStateCache* fPipelineStateCache;

     SkSTArray<4, GrVkDescriptorSetManager, true> fDescriptorSetManagers;

     GrVkDescriptorSetManager::Handle fUniformDSHandle;
 };

 #endif
	/*
	* 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 "GrGpu.h"
	#include "GrResourceHandle.h"
	#include "GrVkDescriptorPool.h"
	#include "GrVkDescriptorSetManager.h"
	#include "GrVkPipelineState.h"
	#include "GrVkRenderPass.h"
	#include "GrVkResource.h"
	#include "GrVkUtil.h"
	#include "SkTArray.h"
	#include "SkTDynamicHash.h"
	#include "SkTHash.h"
	#include "SkTInternalLList.h"

	#include "vk/GrVkDefines.h"

	class GrPipeline;
	class GrPrimitiveProcessor;
	class GrTextureParams;
	class GrVkCopyPipeline;
	class GrVkGpu;
	class GrVkPipeline;
	class GrVkPrimaryCommandBuffer;
	class GrVkRenderTarget;
	class GrVkSampler;
	class GrVkSecondaryCommandBuffer;
	class GrVkUniformHandler;

	class GrVkResourceProvider {
	public:
	GrVkResourceProvider(GrVkGpu* gpu);
	~GrVkResourceProvider();

	// Set up any initial vk objects
	void init();

	GrVkPipeline* createPipeline(const GrPipeline& pipeline,
	const GrStencilSettings& stencil,
	const GrPrimitiveProcessor& primProc,
	VkPipelineShaderStageCreateInfo* shaderStageInfo,
	int shaderStageCount,
	GrPrimitiveType primitiveType,
	const GrVkRenderPass& renderPass,
	VkPipelineLayout layout);

	GrVkCopyPipeline* findOrCreateCopyPipeline(const GrVkRenderTarget* dst,
	VkPipelineShaderStageCreateInfo*,
	VkPipelineLayout);

	GR_DEFINE_RESOURCE_HANDLE_CLASS(CompatibleRPHandle);

	// 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(const GrVkRenderTarget& target,
	CompatibleRPHandle* compatibleHandle = nullptr);
	// The CompatibleRPHandle must be a valid handle previously set by a call to
	// findCompatibleRenderPass(GrVkRenderTarget&, CompatibleRPHandle*).
	const GrVkRenderPass* findCompatibleRenderPass(const CompatibleRPHandle& compatibleHandle);

	// 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 furutre to quickly
	// return a GrVkRenderPasses without the need inspecting a GrVkRenderTarget.
	const GrVkRenderPass* findRenderPass(const GrVkRenderTarget& target,
	const GrVkRenderPass::LoadStoreOps& colorOps,
	const GrVkRenderPass::LoadStoreOps& stencilOps,
	CompatibleRPHandle* compatibleHandle = nullptr);

	// 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& stencilOps);

	GrVkPrimaryCommandBuffer* findOrCreatePrimaryCommandBuffer();
	void checkCommandBuffers();

	GrVkSecondaryCommandBuffer* findOrCreateSecondaryCommandBuffer();
	void recycleSecondaryCommandBuffer(GrVkSecondaryCommandBuffer* cb);

	// 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 GrTextureParams.
	// The refcount is incremented and a pointer returned.
	GrVkSampler* findOrCreateCompatibleSampler(const GrTextureParams&, uint32_t mipLevels);

	sk_sp<GrVkPipelineState> findOrCreateCompatiblePipelineState(const GrPipeline&,
	const GrPrimitiveProcessor&,
	GrPrimitiveType,
	const GrVkRenderPass& renderPass);

	void getSamplerDescriptorSetHandle(const GrVkUniformHandler&,
	GrVkDescriptorSetManager::Handle* handle);
	void getSamplerDescriptorSetHandle(const SkTArray<uint32_t>& visibilities,
	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 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&);


	// 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&);

	// Creates or finds free uniform buffer resources of size GrVkUniformBuffer::kStandardSize.
	// Anything larger will need to be created and released by the client.
	const GrVkResource* findOrCreateStandardUniformBufferResource();

	// Signals that the resource passed to it (which should be a uniform buffer resource)
	// can be reused by the next uniform buffer resource request.
	void recycleStandardUniformBufferResource(const GrVkResource*);

	// 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.
	// If deviceLost is true, then resources will not be checked to see if they've finished
	// before deleting (see section 4.2.4 of the Vulkan spec).
	void destroyResources(bool deviceLost);

	// Abandon any cached resources. To be used when the context/VkDevice is lost.
	// For resource tracing to work properly, this should be called after unrefing all other
	// resource usages.
	void abandonResources();

	private:
	#ifdef SK_DEBUG
	#define GR_PIPELINE_STATE_CACHE_STATS
	#endif

	class PipelineStateCache : public ::SkNoncopyable {
	public:
	PipelineStateCache(GrVkGpu* gpu);
	~PipelineStateCache();

	void abandon();
	void release();
	sk_sp<GrVkPipelineState> refPipelineState(const GrPipeline&,
	const GrPrimitiveProcessor&,
	GrPrimitiveType,
	const GrVkRenderPass& renderPass);

	private:
	enum {
	// We may actually have kMaxEntries+1 PipelineStates in context because we create a new
	// PipelineState before evicting from the cache.
	kMaxEntries = 128,
	};

	struct Entry;

	void reset();

	int fCount;
	SkTHashTable<Entry*, const GrVkPipelineState::Desc&, Entry> fHashTable;
	SkTInternalLList<Entry> fLRUList;

	GrVkGpu* fGpu;

	#ifdef GR_PIPELINE_STATE_CACHE_STATS
	int fTotalRequests;
	int fCacheMisses;
	#endif
	};

	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(const GrVkGpu* gpu, const GrVkRenderTarget& target);

	bool isCompatible(const GrVkRenderTarget& target) 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(const GrVkGpu* gpu,
	const GrVkRenderPass::LoadStoreOps& colorOps,
	const GrVkRenderPass::LoadStoreOps& stencilOps);

	void releaseResources(const GrVkGpu* gpu);
	void abandonResources();

	private:
	SkSTArray<4, GrVkRenderPass*> fRenderPasses;
	int fLastReturnedIndex;
	};

	GrVkGpu* fGpu;

	// Central cache for creating pipelines
	VkPipelineCache fPipelineCache;

	// Cache of previously created copy pipelines
	SkTArray<GrVkCopyPipeline*> fCopyPipelines;

	SkSTArray<4, CompatibleRenderPassSet> fRenderPassArray;

	// Array of PrimaryCommandBuffers that are currently in flight
	SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fActiveCommandBuffers;
	// Array of available primary command buffers that are not in flight
	SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fAvailableCommandBuffers;

	// Array of available secondary command buffers
	SkSTArray<16, GrVkSecondaryCommandBuffer*, true> fAvailableSecondaryCommandBuffers;

	// Array of available uniform buffer resources
	SkSTArray<16, const GrVkResource*, true> fAvailableUniformBufferResources;

	// Stores GrVkSampler objects that we've already created so we can reuse them across multiple
	// GrVkPipelineStates
	SkTDynamicHash<GrVkSampler, uint16_t> fSamplers;

	// Cache of GrVkPipelineStates
	PipelineStateCache* fPipelineStateCache;

	SkSTArray<4, GrVkDescriptorSetManager, true> fDescriptorSetManagers;

	GrVkDescriptorSetManager::Handle fUniformDSHandle;
	};

	#endif