Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | List of all members
skgpu::graphite::VulkanSharedContext Class Referencefinal

#include <VulkanSharedContext.h>

Inheritance diagram for skgpu::graphite::VulkanSharedContext:
skgpu::graphite::SharedContext SkRefCnt SkRefCntBase

Public Member Functions

 ~VulkanSharedContext () override
 
const VulkanCapsvulkanCaps () const
 
const skgpu::VulkanInterfaceinterface () const
 
skgpu::VulkanMemoryAllocatormemoryAllocator () const
 
VkDevice device () const
 
uint32_t queueIndex () const
 
std::unique_ptr< ResourceProvidermakeResourceProvider (SingleOwner *, uint32_t recorderID, size_t resourceBudget) override
 
bool checkVkResult (VkResult result) const
 
bool isDeviceLost () const override
 
- Public Member Functions inherited from skgpu::graphite::SharedContext
 ~SharedContext () override
 
const Capscaps () const
 
BackendApi backend () const
 
Protected isProtected () const
 
GlobalCacheglobalCache ()
 
const GlobalCacheglobalCache () const
 
const RendererProviderrendererProvider () const
 
ShaderCodeDictionaryshaderCodeDictionary ()
 
const ShaderCodeDictionaryshaderCodeDictionary () const
 
- Public Member Functions inherited from SkRefCntBase
 SkRefCntBase ()
 
virtual ~SkRefCntBase ()
 
bool unique () const
 
void ref () const
 
void unref () const
 

Static Public Member Functions

static sk_sp< SharedContextMake (const VulkanBackendContext &, const ContextOptions &)
 

Additional Inherited Members

- Protected Member Functions inherited from skgpu::graphite::SharedContext
 SharedContext (std::unique_ptr< const Caps >, BackendApi)
 

Detailed Description

Definition at line 28 of file VulkanSharedContext.h.

Constructor & Destructor Documentation

◆ ~VulkanSharedContext()

skgpu::graphite::VulkanSharedContext::~VulkanSharedContext ( )
override

Definition at line 141 of file VulkanSharedContext.cpp.

141 {
142 // need to clear out resources before the allocator is removed
143 this->globalCache()->deleteResources();
144}

Member Function Documentation

◆ checkVkResult()

bool skgpu::graphite::VulkanSharedContext::checkVkResult ( VkResult  result) const

Definition at line 190 of file VulkanSharedContext.cpp.

190 {
191 switch (result) {
192 case VK_SUCCESS:
193 return true;
195 {
196 SkAutoMutexExclusive lock(fDeviceIsLostMutex);
197 if (fDeviceIsLost) {
198 return false;
199 }
200 fDeviceIsLost = true;
201 // Fall through to InvokeDeviceLostCallback (on first VK_ERROR_DEVICE_LOST) only afer
202 // releasing fDeviceIsLostMutex, otherwise clients might cause deadlock by checking
203 // isDeviceLost() from the callback.
204 }
206 device(),
207 fDeviceLostContext,
208 fDeviceLostProc,
209 vulkanCaps().supportsDeviceFaultInfo());
210 return false;
213 // TODO: determine how we'll track this in a thread-safe manner
214 //this->setOOMed();
215 return false;
216 default:
217 return false;
218 }
219}
const skgpu::VulkanInterface * interface() const
const VulkanCaps & vulkanCaps() const
GAsyncResult * result
void InvokeDeviceLostCallback(const skgpu::VulkanInterface *vulkanInterface, VkDevice vkDevice, skgpu::VulkanDeviceLostContext deviceLostContext, skgpu::VulkanDeviceLostProc deviceLostProc, bool supportsDeviceFaultInfoExtension)
@ VK_ERROR_DEVICE_LOST
@ VK_SUCCESS
@ VK_ERROR_OUT_OF_HOST_MEMORY
@ VK_ERROR_OUT_OF_DEVICE_MEMORY

◆ device()

VkDevice skgpu::graphite::VulkanSharedContext::device ( ) const
inline

Definition at line 39 of file VulkanSharedContext.h.

39{ return fDevice; }

◆ interface()

const skgpu::VulkanInterface * skgpu::graphite::VulkanSharedContext::interface ( ) const
inline

Definition at line 35 of file VulkanSharedContext.h.

35{ return fInterface.get(); }
T * get() const
Definition SkRefCnt.h:303

◆ isDeviceLost()

bool skgpu::graphite::VulkanSharedContext::isDeviceLost ( ) const
inlineoverridevirtual

Reimplemented from skgpu::graphite::SharedContext.

Definition at line 48 of file VulkanSharedContext.h.

48 {
49 SkAutoMutexExclusive lock(fDeviceIsLostMutex);
50 return fDeviceIsLost;
51 }

◆ Make()

sk_sp< SharedContext > skgpu::graphite::VulkanSharedContext::Make ( const VulkanBackendContext context,
const ContextOptions options 
)
static

Definition at line 24 of file VulkanSharedContext.cpp.

25 {
26 if (context.fInstance == VK_NULL_HANDLE ||
27 context.fPhysicalDevice == VK_NULL_HANDLE ||
28 context.fDevice == VK_NULL_HANDLE ||
29 context.fQueue == VK_NULL_HANDLE) {
30 SKGPU_LOG_E("Failed to create VulkanSharedContext because either fInstance,"
31 "fPhysicalDevice, fDevice, or fQueue in the VulkanBackendContext is"
32 "VK_NULL_HANDLE.");
33 return nullptr;
34 }
35 if (!context.fGetProc) {
36 SKGPU_LOG_E("Failed to create VulkanSharedContext because there is no valid VulkanGetProc"
37 "on the VulkanBackendContext");
38 return nullptr;
39 }
40
41 PFN_vkEnumerateInstanceVersion localEnumerateInstanceVersion =
42 reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
43 context.fGetProc("vkEnumerateInstanceVersion", VK_NULL_HANDLE, VK_NULL_HANDLE));
44 uint32_t instanceVersion = 0;
45 if (!localEnumerateInstanceVersion) {
46 instanceVersion = VK_MAKE_VERSION(1, 0, 0);
47 } else {
48 VkResult err = localEnumerateInstanceVersion(&instanceVersion);
49 if (err) {
50 SKGPU_LOG_E("Failed to enumerate instance version. Err: %d\n", err);
51 return nullptr;
52 }
53 }
54
55 PFN_vkGetPhysicalDeviceProperties localGetPhysicalDeviceProperties =
56 reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
57 context.fGetProc("vkGetPhysicalDeviceProperties",
58 context.fInstance,
60
61 if (!localGetPhysicalDeviceProperties) {
62 SKGPU_LOG_E("Failed to get function pointer to vkGetPhysicalDeviceProperties.");
63 return nullptr;
64 }
65 VkPhysicalDeviceProperties physDeviceProperties;
66 localGetPhysicalDeviceProperties(context.fPhysicalDevice, &physDeviceProperties);
67 uint32_t physDevVersion = physDeviceProperties.apiVersion;
68
69 uint32_t apiVersion = context.fMaxAPIVersion ? context.fMaxAPIVersion : instanceVersion;
70
71 instanceVersion = std::min(instanceVersion, apiVersion);
72 physDevVersion = std::min(physDevVersion, apiVersion);
73
75 new skgpu::VulkanInterface(context.fGetProc,
76 context.fInstance,
77 context.fDevice,
78 instanceVersion,
79 physDevVersion,
80 context.fVkExtensions));
81 if (!interface->validate(instanceVersion, physDevVersion, context.fVkExtensions)) {
82 SKGPU_LOG_E("Failed to validate VulkanInterface.");
83 return nullptr;
84 }
85
87 const VkPhysicalDeviceFeatures2* featuresPtr;
88 // If fDeviceFeatures2 is not null, then we ignore fDeviceFeatures. If both are null, we assume
89 // no features are enabled.
90 if (!context.fDeviceFeatures2 && context.fDeviceFeatures) {
91 features.pNext = nullptr;
92 features.features = *context.fDeviceFeatures;
93 featuresPtr = &features;
94 } else {
95 featuresPtr = context.fDeviceFeatures2;
96 }
97
98 std::unique_ptr<const VulkanCaps> caps(new VulkanCaps(options,
99 interface.get(),
100 context.fPhysicalDevice,
101 physDevVersion,
102 featuresPtr,
103 context.fVkExtensions,
104 context.fProtectedContext));
105
106 sk_sp<skgpu::VulkanMemoryAllocator> memoryAllocator = context.fMemoryAllocator;
107 if (!memoryAllocator) {
108 // We were not given a memory allocator at creation
109 bool threadSafe = !options.fClientWillExternallySynchronizeAllThreads;
111 context.fPhysicalDevice,
112 context.fDevice,
113 physDevVersion,
114 context.fVkExtensions,
115 interface.get(),
116 threadSafe);
117 }
118 if (!memoryAllocator) {
119 SKGPU_LOG_E("No supplied vulkan memory allocator and unable to create one internally.");
120 return nullptr;
121 }
122
123 return sk_sp<SharedContext>(new VulkanSharedContext(context,
124 std::move(interface),
125 std::move(memoryAllocator),
126 std::move(caps)));
127}
const char * options
#define SKGPU_LOG_E(fmt,...)
Definition Log.h:38
static sk_sp< VulkanMemoryAllocator > Make(VkInstance instance, VkPhysicalDevice physicalDevice, VkDevice device, uint32_t physicalDeviceVersion, const VulkanExtensions *extensions, const VulkanInterface *interface, bool threadSafe)
const Caps * caps() const
skgpu::VulkanMemoryAllocator * memoryAllocator() const
VkPhysicalDeviceFeatures features
bool validate(uint32_t instanceVersion, uint32_t physicalDeviceVersion, const VulkanExtensions *) const
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
#define VK_MAKE_VERSION(major, minor, patch)
Definition vulkan_core.h:78
VkResult
#define VK_NULL_HANDLE
Definition vulkan_core.h:46
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)

◆ makeResourceProvider()

std::unique_ptr< ResourceProvider > skgpu::graphite::VulkanSharedContext::makeResourceProvider ( SingleOwner singleOwner,
uint32_t  recorderID,
size_t  resourceBudget 
)
overridevirtual

Implements skgpu::graphite::SharedContext.

Definition at line 146 of file VulkanSharedContext.cpp.

149 {
150 // Establish a uniform buffer that can be updated across multiple render passes and cmd buffers
151 size_t alignedIntrinsicConstantSize =
153 this->vulkanCaps().requiredUniformBufferAlignment());
154 sk_sp<Buffer> intrinsicConstantBuffer = VulkanBuffer::Make(this,
155 alignedIntrinsicConstantSize,
158 "IntrinsicConstantBuffer");
159 if (!intrinsicConstantBuffer) {
160 SKGPU_LOG_E("Failed to create intrinsic constant uniform buffer");
161 return nullptr;
162 }
163 SkASSERT(static_cast<VulkanBuffer*>(intrinsicConstantBuffer.get())->bufferUsageFlags()
165
166 // Establish a vertex buffer that can be updated across multiple render passes and cmd buffers
167 // for loading MSAA from resolve
168 sk_sp<Buffer> loadMSAAVertexBuffer =
173 "LoadMSAAVertexBuffer");
174 if (!loadMSAAVertexBuffer) {
175 SKGPU_LOG_E("Failed to create vertex buffer for loading MSAA from resolve");
176 return nullptr;
177 }
178 SkASSERT(static_cast<VulkanBuffer*>(loadMSAAVertexBuffer.get())->bufferUsageFlags()
180
181 return std::unique_ptr<ResourceProvider>(
182 new VulkanResourceProvider(this,
183 singleOwner,
184 recorderID,
185 resourceBudget,
186 std::move(intrinsicConstantBuffer),
187 std::move(loadMSAAVertexBuffer)));
188}
#define SkASSERT(cond)
Definition SkAssert.h:116
static sk_sp< Buffer > Make(const VulkanSharedContext *, size_t, BufferType, AccessPattern, std::string_view label)
@ VK_BUFFER_USAGE_TRANSFER_DST_BIT
@ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT

◆ memoryAllocator()

skgpu::VulkanMemoryAllocator * skgpu::graphite::VulkanSharedContext::memoryAllocator ( ) const
inline

Definition at line 37 of file VulkanSharedContext.h.

37{ return fMemoryAllocator.get(); }

◆ queueIndex()

uint32_t skgpu::graphite::VulkanSharedContext::queueIndex ( ) const
inline

Definition at line 40 of file VulkanSharedContext.h.

40{ return fQueueIndex; }

◆ vulkanCaps()

const VulkanCaps & skgpu::graphite::VulkanSharedContext::vulkanCaps ( ) const
inline

Definition at line 33 of file VulkanSharedContext.h.

33{ return static_cast<const VulkanCaps&>(*this->caps()); }

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