OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 | 9 |
10 #include "GrResourceCache.h" | 10 #include "GrResourceCache.h" |
11 #include "GrGpuResourceCacheAccess.h" | 11 #include "GrGpuResourceCacheAccess.h" |
| 12 #include "GrTracing.h" |
12 #include "SkChecksum.h" | 13 #include "SkChecksum.h" |
13 #include "SkGr.h" | 14 #include "SkGr.h" |
14 #include "SkMessageBus.h" | 15 #include "SkMessageBus.h" |
15 #include "SkTSort.h" | 16 #include "SkTSort.h" |
16 | 17 |
17 DECLARE_SKMESSAGEBUS_MESSAGE(GrUniqueKeyInvalidatedMessage); | 18 DECLARE_SKMESSAGEBUS_MESSAGE(GrUniqueKeyInvalidatedMessage); |
18 | 19 |
19 ////////////////////////////////////////////////////////////////////////////// | 20 ////////////////////////////////////////////////////////////////////////////// |
20 | 21 |
21 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() { | 22 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() { |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 size_t size = resource->gpuMemorySize(); | 102 size_t size = resource->gpuMemorySize(); |
102 SkDEBUGCODE(++fCount;) | 103 SkDEBUGCODE(++fCount;) |
103 fBytes += size; | 104 fBytes += size; |
104 #if GR_CACHE_STATS | 105 #if GR_CACHE_STATS |
105 fHighWaterCount = SkTMax(this->getResourceCount(), fHighWaterCount); | 106 fHighWaterCount = SkTMax(this->getResourceCount(), fHighWaterCount); |
106 fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes); | 107 fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes); |
107 #endif | 108 #endif |
108 if (resource->resourcePriv().isBudgeted()) { | 109 if (resource->resourcePriv().isBudgeted()) { |
109 ++fBudgetedCount; | 110 ++fBudgetedCount; |
110 fBudgetedBytes += size; | 111 fBudgetedBytes += size; |
| 112 TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget
", "used", |
| 113 fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes); |
111 #if GR_CACHE_STATS | 114 #if GR_CACHE_STATS |
112 fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount
); | 115 fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount
); |
113 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); | 116 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); |
114 #endif | 117 #endif |
115 } | 118 } |
116 if (resource->resourcePriv().getScratchKey().isValid()) { | 119 if (resource->resourcePriv().getScratchKey().isValid()) { |
117 SkASSERT(!resource->cacheAccess().isWrapped()); | 120 SkASSERT(!resource->cacheAccess().isWrapped()); |
118 fScratchMap.insert(resource->resourcePriv().getScratchKey(), resource); | 121 fScratchMap.insert(resource->resourcePriv().getScratchKey(), resource); |
119 } | 122 } |
120 | 123 |
121 this->purgeAsNeeded(); | 124 this->purgeAsNeeded(); |
122 } | 125 } |
123 | 126 |
124 void GrResourceCache::removeResource(GrGpuResource* resource) { | 127 void GrResourceCache::removeResource(GrGpuResource* resource) { |
125 this->validate(); | 128 this->validate(); |
126 SkASSERT(this->isInCache(resource)); | 129 SkASSERT(this->isInCache(resource)); |
127 | 130 |
128 if (resource->isPurgeable()) { | 131 if (resource->isPurgeable()) { |
129 fPurgeableQueue.remove(resource); | 132 fPurgeableQueue.remove(resource); |
130 } else { | 133 } else { |
131 this->removeFromNonpurgeableArray(resource); | 134 this->removeFromNonpurgeableArray(resource); |
132 } | 135 } |
133 | 136 |
134 size_t size = resource->gpuMemorySize(); | 137 size_t size = resource->gpuMemorySize(); |
135 SkDEBUGCODE(--fCount;) | 138 SkDEBUGCODE(--fCount;) |
136 fBytes -= size; | 139 fBytes -= size; |
137 if (resource->resourcePriv().isBudgeted()) { | 140 if (resource->resourcePriv().isBudgeted()) { |
138 --fBudgetedCount; | 141 --fBudgetedCount; |
139 fBudgetedBytes -= size; | 142 fBudgetedBytes -= size; |
| 143 TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget
", "used", |
| 144 fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes); |
140 } | 145 } |
141 | 146 |
142 if (resource->resourcePriv().getScratchKey().isValid()) { | 147 if (resource->resourcePriv().getScratchKey().isValid()) { |
143 fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource); | 148 fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource); |
144 } | 149 } |
145 if (resource->getUniqueKey().isValid()) { | 150 if (resource->getUniqueKey().isValid()) { |
146 fUniqueHash.remove(resource->getUniqueKey()); | 151 fUniqueHash.remove(resource->getUniqueKey()); |
147 } | 152 } |
148 this->validate(); | 153 this->validate(); |
149 } | 154 } |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
344 SkASSERT(this->isInCache(resource)); | 349 SkASSERT(this->isInCache(resource)); |
345 | 350 |
346 ptrdiff_t delta = resource->gpuMemorySize() - oldSize; | 351 ptrdiff_t delta = resource->gpuMemorySize() - oldSize; |
347 | 352 |
348 fBytes += delta; | 353 fBytes += delta; |
349 #if GR_CACHE_STATS | 354 #if GR_CACHE_STATS |
350 fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes); | 355 fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes); |
351 #endif | 356 #endif |
352 if (resource->resourcePriv().isBudgeted()) { | 357 if (resource->resourcePriv().isBudgeted()) { |
353 fBudgetedBytes += delta; | 358 fBudgetedBytes += delta; |
| 359 TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget
", "used", |
| 360 fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes); |
354 #if GR_CACHE_STATS | 361 #if GR_CACHE_STATS |
355 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); | 362 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); |
356 #endif | 363 #endif |
357 } | 364 } |
358 | 365 |
359 this->purgeAsNeeded(); | 366 this->purgeAsNeeded(); |
360 this->validate(); | 367 this->validate(); |
361 } | 368 } |
362 | 369 |
363 void GrResourceCache::didChangeBudgetStatus(GrGpuResource* resource) { | 370 void GrResourceCache::didChangeBudgetStatus(GrGpuResource* resource) { |
364 SkASSERT(resource); | 371 SkASSERT(resource); |
365 SkASSERT(this->isInCache(resource)); | 372 SkASSERT(this->isInCache(resource)); |
366 | 373 |
367 size_t size = resource->gpuMemorySize(); | 374 size_t size = resource->gpuMemorySize(); |
368 | 375 |
369 if (resource->resourcePriv().isBudgeted()) { | 376 if (resource->resourcePriv().isBudgeted()) { |
370 ++fBudgetedCount; | 377 ++fBudgetedCount; |
371 fBudgetedBytes += size; | 378 fBudgetedBytes += size; |
372 #if GR_CACHE_STATS | 379 #if GR_CACHE_STATS |
373 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); | 380 fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes
); |
374 fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount
); | 381 fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount
); |
375 #endif | 382 #endif |
376 this->purgeAsNeeded(); | 383 this->purgeAsNeeded(); |
377 } else { | 384 } else { |
378 --fBudgetedCount; | 385 --fBudgetedCount; |
379 fBudgetedBytes -= size; | 386 fBudgetedBytes -= size; |
380 } | 387 } |
| 388 TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget", "
used", |
| 389 fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes); |
381 | 390 |
382 this->validate(); | 391 this->validate(); |
383 } | 392 } |
384 | 393 |
385 void GrResourceCache::internalPurgeAsNeeded() { | 394 void GrResourceCache::internalPurgeAsNeeded() { |
386 SkASSERT(this->overBudget()); | 395 SkASSERT(this->overBudget()); |
387 | 396 |
388 bool stillOverbudget = true; | 397 bool stillOverbudget = true; |
389 while (fPurgeableQueue.count()) { | 398 while (fPurgeableQueue.count()) { |
390 GrGpuResource* resource = fPurgeableQueue.peek(); | 399 GrGpuResource* resource = fPurgeableQueue.peek(); |
(...skipping 230 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
621 return true; | 630 return true; |
622 } | 631 } |
623 if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index]
== resource) { | 632 if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index]
== resource) { |
624 return true; | 633 return true; |
625 } | 634 } |
626 SkDEBUGFAIL("Resource index should be -1 or the resource should be in the ca
che."); | 635 SkDEBUGFAIL("Resource index should be -1 or the resource should be in the ca
che."); |
627 return false; | 636 return false; |
628 } | 637 } |
629 | 638 |
630 #endif | 639 #endif |
OLD | NEW |