1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7 #include "src/gpu/ganesh/GrGpuResource.h"
8
9 #include "include/core/SkTraceMemoryDump.h"
10 #include "include/gpu/GpuTypes.h"
11 #include "include/gpu/ganesh/GrDirectContext.h"
12 #include "include/private/base/SkDebug.h"
13 #include "src/gpu/ganesh/GrDirectContextPriv.h"
14 #include "src/gpu/ganesh/GrGpu.h"
15 #include "src/gpu/ganesh/GrGpuResourcePriv.h"
16 #include "src/gpu/ganesh/GrResourceCache.h"
17
18 #include <atomic>
19
get_resource_cache(GrGpu * gpu)20 static inline GrResourceCache* get_resource_cache(GrGpu* gpu) {
21 SkASSERT(gpu);
22 SkASSERT(gpu->getContext());
23 SkASSERT(gpu->getContext()->priv().getResourceCache());
24 return gpu->getContext()->priv().getResourceCache();
25 }
26
GrGpuResource(GrGpu * gpu,std::string_view label)27 GrGpuResource::GrGpuResource(GrGpu* gpu, std::string_view label)
28 : fGpu(gpu), fUniqueID(CreateUniqueID()), fLabel(label) {
29 SkDEBUGCODE(fCacheArrayIndex = -1);
30 auto cache = get_resource_cache(fGpu);
31 if (cache) {
32 fGrResourceTag = cache->resourceAccess().getCurrentGrResourceTag();
33 }
34 }
35
registerWithCache(skgpu::Budgeted budgeted)36 void GrGpuResource::registerWithCache(skgpu::Budgeted budgeted) {
37 SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable);
38 fBudgetedType = budgeted == skgpu::Budgeted::kYes ? GrBudgetedType::kBudgeted
39 : GrBudgetedType::kUnbudgetedUncacheable;
40 this->computeScratchKey(&fScratchKey);
41 get_resource_cache(fGpu)->resourceAccess().insertResource(this);
42 }
43
registerWithCacheWrapped(GrWrapCacheable wrapType)44 void GrGpuResource::registerWithCacheWrapped(GrWrapCacheable wrapType) {
45 SkASSERT(fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable);
46 // Resources referencing wrapped objects are never budgeted. They may be cached or uncached.
47 fBudgetedType = wrapType == GrWrapCacheable::kNo ? GrBudgetedType::kUnbudgetedUncacheable
48 : GrBudgetedType::kUnbudgetedCacheable;
49 fRefsWrappedObjects = true;
50 get_resource_cache(fGpu)->resourceAccess().insertResource(this);
51 }
52
~GrGpuResource()53 GrGpuResource::~GrGpuResource() {
54 // The cache should have released or destroyed this resource.
55 SkASSERT(this->wasDestroyed());
56 }
57
release()58 void GrGpuResource::release() {
59 SkASSERT(fGpu);
60 this->onRelease();
61 get_resource_cache(fGpu)->resourceAccess().removeResource(this);
62 fGpu = nullptr;
63 fGpuMemorySize = 0;
64 }
65
abandon()66 void GrGpuResource::abandon() {
67 if (this->wasDestroyed()) {
68 return;
69 }
70 SkASSERT(fGpu);
71 this->onAbandon();
72 get_resource_cache(fGpu)->resourceAccess().removeResource(this);
73 fGpu = nullptr;
74 fGpuMemorySize = 0;
75 }
76
dumpMemoryStatistics(SkTraceMemoryDump * traceMemoryDump) const77 void GrGpuResource::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
78 if (this->fRefsWrappedObjects && !traceMemoryDump->shouldDumpWrappedObjects()) {
79 return;
80 }
81
82 this->dumpMemoryStatisticsPriv(traceMemoryDump, this->getResourceName(),
83 this->getResourceType(), this->gpuMemorySize());
84 }
85
dumpMemoryStatisticsPriv(SkTraceMemoryDump * traceMemoryDump,const SkString & resourceName,const char * type,size_t size) const86 void GrGpuResource::dumpMemoryStatisticsPriv(SkTraceMemoryDump* traceMemoryDump,
87 const SkString& resourceName,
88 const char* type, size_t size) const {
89 const char* tag = "Scratch";
90 if (fUniqueKey.isValid()) {
91 tag = (fUniqueKey.tag() != nullptr) ? fUniqueKey.tag() : "Other";
92 }
93
94 traceMemoryDump->dumpNumericValue(resourceName.c_str(), "size", "bytes", size);
95 traceMemoryDump->dumpStringValue(resourceName.c_str(), "type", type);
96 traceMemoryDump->dumpStringValue(resourceName.c_str(), "label", this->getLabel().c_str());
97 traceMemoryDump->dumpStringValue(resourceName.c_str(), "category", tag);
98 if (this->isPurgeable()) {
99 traceMemoryDump->dumpNumericValue(resourceName.c_str(), "purgeable_size", "bytes", size);
100 }
101 if (traceMemoryDump->shouldDumpWrappedObjects()) {
102 traceMemoryDump->dumpWrappedState(resourceName.c_str(), fRefsWrappedObjects);
103 }
104
105 this->setMemoryBacking(traceMemoryDump, resourceName);
106 }
107
isPurgeable() const108 bool GrGpuResource::isPurgeable() const {
109 // Resources in the kUnbudgetedCacheable state are never purgeable when they have a unique
110 // key. The key must be removed/invalidated to make them purgeable.
111 return !this->hasRef() &&
112 this->hasNoCommandBufferUsages() &&
113 !(fBudgetedType == GrBudgetedType::kUnbudgetedCacheable && fUniqueKey.isValid());
114 }
115
hasRef() const116 bool GrGpuResource::hasRef() const { return this->internalHasRef(); }
117
hasNoCommandBufferUsages() const118 bool GrGpuResource::hasNoCommandBufferUsages() const {
119 return this->internalHasNoCommandBufferUsages();
120 }
121
getResourceName() const122 SkString GrGpuResource::getResourceName() const {
123 // Dump resource as "skia/gpu_resources/resource_#".
124 SkString resourceName("skia/gpu_resources/resource_");
125 resourceName.appendU32(this->uniqueID().asUInt());
126 return resourceName;
127 }
128
getContext() const129 const GrDirectContext* GrGpuResource::getContext() const {
130 if (fGpu) {
131 return fGpu->getContext();
132 } else {
133 return nullptr;
134 }
135 }
136
getContext()137 GrDirectContext* GrGpuResource::getContext() {
138 if (fGpu) {
139 return fGpu->getContext();
140 } else {
141 return nullptr;
142 }
143 }
144
removeUniqueKey()145 void GrGpuResource::removeUniqueKey() {
146 if (this->wasDestroyed()) {
147 return;
148 }
149 SkASSERT(fUniqueKey.isValid());
150 get_resource_cache(fGpu)->resourceAccess().removeUniqueKey(this);
151 }
152
setUniqueKey(const skgpu::UniqueKey & key)153 void GrGpuResource::setUniqueKey(const skgpu::UniqueKey& key) {
154 SkASSERT(this->internalHasRef());
155 SkASSERT(key.isValid());
156
157 // Uncached resources can never have a unique key, unless they're wrapped resources. Wrapped
158 // resources are a special case: the unique keys give us a weak ref so that we can reuse the
159 // same resource (rather than re-wrapping). When a wrapped resource is no longer referenced,
160 // it will always be released - it is never converted to a scratch resource.
161 if (this->resourcePriv().budgetedType() != GrBudgetedType::kBudgeted &&
162 !this->fRefsWrappedObjects) {
163 return;
164 }
165
166 if (this->wasDestroyed()) {
167 return;
168 }
169
170 get_resource_cache(fGpu)->resourceAccess().changeUniqueKey(this, key);
171 }
172
notifyARefCntIsZero(LastRemovedRef removedRef) const173 void GrGpuResource::notifyARefCntIsZero(LastRemovedRef removedRef) const {
174 if (this->wasDestroyed()) {
175 if (this->hasNoCommandBufferUsages() && !this->hasRef()) {
176 // We've already been removed from the cache. Goodbye cruel world!
177 delete this;
178 }
179 return;
180 }
181
182 GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this);
183
184 get_resource_cache(fGpu)->resourceAccess().notifyARefCntReachedZero(mutableThis, removedRef);
185 }
186
removeScratchKey()187 void GrGpuResource::removeScratchKey() {
188 if (!this->wasDestroyed() && fScratchKey.isValid()) {
189 get_resource_cache(fGpu)->resourceAccess().willRemoveScratchKey(this);
190 fScratchKey.reset();
191 }
192 }
193
makeBudgeted()194 void GrGpuResource::makeBudgeted() {
195 // We should never make a wrapped resource budgeted.
196 SkASSERT(!fRefsWrappedObjects);
197 // Only wrapped resources can be in the kUnbudgetedCacheable state.
198 SkASSERT(fBudgetedType != GrBudgetedType::kUnbudgetedCacheable);
199 if (!this->wasDestroyed() && fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable) {
200 // Currently resources referencing wrapped objects are not budgeted.
201 fBudgetedType = GrBudgetedType::kBudgeted;
202 get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this);
203 }
204 }
205
makeUnbudgeted()206 void GrGpuResource::makeUnbudgeted() {
207 if (!this->wasDestroyed() && fBudgetedType == GrBudgetedType::kBudgeted &&
208 !fUniqueKey.isValid()) {
209 fBudgetedType = GrBudgetedType::kUnbudgetedUncacheable;
210 get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this);
211 }
212 }
213
userRegisterResource()214 void GrGpuResource::userRegisterResource() {
215 if (this->wasDestroyed()) {
216 return;
217 }
218 SkASSERT(!fScratchKey.isValid());
219 SkASSERT(!fUniqueKey.isValid());
220 if (fCacheArrayIndex >= 0 && fBudgetedType == GrBudgetedType::kUnbudgetedUncacheable) {
221 this->computeScratchKey(&fScratchKey);
222 makeBudgeted();
223 }
224 }
225
CreateUniqueID()226 uint32_t GrGpuResource::CreateUniqueID() {
227 static std::atomic<uint32_t> nextID{1};
228 uint32_t id;
229 do {
230 id = nextID.fetch_add(1, std::memory_order_relaxed);
231 } while (id == SK_InvalidUniqueID);
232 return id;
233 }
234
setResourceTag(const GrGpuResourceTag tag,bool curRealAlloc)235 void GrGpuResource::setResourceTag(const GrGpuResourceTag tag, bool curRealAlloc)
236 {
237 int32_t pid = fGrResourceTag.fPid;
238 fGrResourceTag = tag;
239 if ((pid == tag.fPid) && (fRealAlloc == curRealAlloc)) {
240 return;
241 }
242 size_t size = this->gpuMemorySize();
243 get_resource_cache(fGpu)->resourceAccess().changeByteOfPid(pid, tag.fPid, size, fRealAlloc, curRealAlloc);
244 fRealAlloc = curRealAlloc;
245 }
246
247 //////////////////////////////////////////////////////////////////////////////
248
ref(GrResourceCache * cache)249 void GrGpuResource::ProxyAccess::ref(GrResourceCache* cache) {
250 SkASSERT(cache == fResource->getContext()->priv().getResourceCache());
251 cache->resourceAccess().refResource(fResource);
252 }
253