Revert of Parallel cache - preliminary (patchset #23 id:440001 of https://codereview.chromium.org/1264103003/ )
Also reverts https://codereview.chromium.org/1333003002/ which was layered on top.
Reason for revert:
Appears to leak GDI handles: http://build.chromium.org/p/chromium.memory.fyi/builders/Windows%20Unit%20%28DrMemory%20full%29%20%282%29/builds/8247
~~Dr.M~~ Error #1: HANDLE LEAK: GDI handle 0x03050a84 and 3 similar handle(s) were opened but not closed:
~~Dr.M~~ # 0 system call NtGdiCreateDIBSection
~~Dr.M~~ # 1 GDI32.dll!CreateDIBSection +0xdc (0x768ead23 <GDI32.dll+0x1ad23>)
~~Dr.M~~ # 2 skia.dll!HDCOffscreen::draw [third_party\skia\src\ports\skfonthost_win.cpp:499]
~~Dr.M~~ # 3 skia.dll!SkScalerContext_GDI::generateImage [third_party\skia\src\ports\skfonthost_win.cpp:1233]
~~Dr.M~~ # 4 skia.dll!SkScalerContext::getImage [third_party\skia\src\core\skscalercontext.cpp:530]
~~Dr.M~~ # 5 skia.dll!SkGlyphCache::OnceFillInImage [third_party\skia\src\core\skglyphcache.cpp:252]
~~Dr.M~~ # 6 skia.dll!sk_once_slow<> [third_party\skia\include\core\skonce.h:76]
~~Dr.M~~ # 7 skia.dll!SkGlyphCache::findImage [third_party\skia\src\core\skglyphcache.cpp:260]
~~Dr.M~~ # 8 skia.dll!D1G_RectClip [third_party\skia\src\core\skdraw.cpp:1479]
~~Dr.M~~ # 9 skia.dll!SkDraw::drawPosText [third_party\skia\src\core\skdraw.cpp:1838]
~~Dr.M~~ #10 skia.dll!SkBitmapDevice::drawPosText [third_party\skia\src\core\skbitmapdevice.cpp:348]
~~Dr.M~~ #11 skia.dll!SkCanvas::onDrawPosText [third_party\skia\src\core\skcanvas.cpp:2433]
~~Dr.M~~ #12 skia.dll!SkCanvas::drawPosText [third_party\skia\src\core\skcanvas.cpp:2507]
~~Dr.M~~ #13 skia.dll!SkRecords::Draw::draw<> [third_party\skia\src\core\skrecorddraw.cpp:109]
~~Dr.M~~ #14 skia.dll!SkRecord::Record::visit<> [third_party\skia\src\core\skrecord.h:170]
~~Dr.M~~ #15 skia.dll!SkRecordDraw [third_party\skia\src\core\skrecorddraw.cpp:55]
~~Dr.M~~ #16 skia.dll!SkBigPicture::playback [third_party\skia\src\core\skbigpicture.cpp:43]
~~Dr.M~~ #17 skia.dll!SkCanvas::onDrawPicture [third_party\skia\src\core\skcanvas.cpp:2800]
~~Dr.M~~ #18 skia.dll!SkCanvas::drawPicture [third_party\skia\src\core\skcanvas.cpp:2770]
~~Dr.M~~ #19 cc.dll!cc::DrawingDisplayItem::Raster [cc\playback\drawing_display_item.cc:51]
~~Dr.M~~ #20 cc.dll!cc::DisplayItemList::Raster [cc\playback\display_item_list.cc:107]
~~Dr.M~~ #21 cc.dll!cc::DisplayListRasterSource::RasterCommon [cc\playback\display_list_raster_source.cc:122]
~~Dr.M~~ #22 cc.dll!cc::DisplayListRasterSource::PlaybackToCanvas [cc\playback\display_list_raster_source.cc:100]
~~Dr.M~~ #23 cc.dll!cc::TileTaskWorkerPool::PlaybackToMemory [cc\raster\tile_task_worker_pool.cc:208]
~~Dr.M~~ #24 cc.dll!cc::OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread [cc\raster\one_copy_tile_task_worker_pool.cc:413]
~~Dr.M~~ #25 cc.dll!cc::`anonymous namespace'::RasterBufferImpl::Playback [cc\raster\one_copy_tile_task_worker_pool.cc:53]
~~Dr.M~~ #26 cc.dll!cc::`anonymous namespace'::RasterTaskImpl::Raster [cc\tiles\tile_manager.cc:131]
~~Dr.M~~ #27 cc.dll!cc::`anonymous namespace'::RasterTaskImpl::RunOnWorkerThread [cc\tiles\tile_manager.cc:90]
~~Dr.M~~ #28 cc.dll!cc::TaskGraphRunner::RunTaskWithLockAcquired [cc\raster\task_graph_runner.cc:418]
~~Dr.M~~ #29 cc.dll!cc::TaskGraphRunner::Run [cc\raster\task_graph_runner.cc:361]
~~Dr.M~~ #30 base.dll!base::SimpleThread::ThreadMain [base\threading\simple_thread.cc:66]
~~Dr.M~~ #31 base.dll!base::`anonymous namespace'::ThreadFunc [base\threading\platform_thread_win.cc:82]
~~Dr.M~~ #32 KERNEL32.dll!BaseThreadInitThunk +0x11 (0x7570337a <KERNEL32.dll+0x1337a>)
~~Dr.M~~ Note: @0:15:51.087 in thread 196
~~Dr.M~~ Note: handles created with the same callstack are closed here:
~~Dr.M~~ Note: # 0 system call NtGdiDeleteObjectApp
~~Dr.M~~ Note: # 1 GDI32.dll!DeleteObject +0x149 (0x768e57d3 <GDI32.dll+0x157d3>)
~~Dr.M~~ Note: # 2 skia.dll!HDCOffscreen::draw [third_party\skia\src\ports\skfonthost_win.cpp:471]
~~Dr.M~~ Note: # 3 skia.dll!SkScalerContext_GDI::generateImage [third_party\skia\src\ports\skfonthost_win.cpp:1233]
~~Dr.M~~ Note: # 4 skia.dll!SkScalerContext::getImage [third_party\skia\src\core\skscalercontext.cpp:530]
~~Dr.M~~ Note: # 5 skia.dll!SkGlyphCache::OnceFillInImage [third_party\skia\src\core\skglyphcache.cpp:252]
~~Dr.M~~ Note: # 6 skia.dll!sk_once_slow<> [third_party\skia\include\core\skonce.h:76]
~~Dr.M~~ Note: # 7 skia.dll!SkGlyphCache::findImage [third_party\skia\src\core\skglyphcache.cpp:260]
~~Dr.M~~ Note: # 8 skia.dll!D1G_RectClip [third_party\skia\src\core\skdraw.cpp:1479]
~~Dr.M~~ Note: # 9 skia.dll!SkDraw::drawPosText [third_party\skia\src\core\skdraw.cpp:1838]
~~Dr.M~~ Note: #10 skia.dll!SkBitmapDevice::drawPosText [third_party\skia\src\core\skbitmapdevice.cpp:348]
~~Dr.M~~ Note: #11 skia.dll!SkCanvas::onDrawPosText [third_party\skia\src\core\skcanvas.cpp:2433]
~~Dr.M~~ Note: #12 skia.dll!SkCanvas::drawPosText [third_party\skia\src\core\skcanvas.cpp:2507]
~~Dr.M~~ Note: #13 skia.dll!SkRecords::Draw::draw<> [third_party\skia\src\core\skrecorddraw.cpp:109]
~~Dr.M~~ Note: #14 skia.dll!SkRecord::Record::visit<> [third_party\skia\src\core\skrecord.h:170]
~~Dr.M~~ Note: #15 skia.dll!SkRecordDraw [third_party\skia\src\core\skrecorddraw.cpp:55]
~~Dr.M~~ Note: #16 skia.dll!SkBigPicture::playback [third_party\skia\src\core\skbigpicture.cpp:43]
~~Dr.M~~ Note: #17 skia.dll!SkCanvas::onDrawPicture [third_party\skia\src\core\skcanvas.cpp:2800]
~~Dr.M~~ Note: #18 skia.dll!SkCanvas::drawPicture [third_party\skia\src\core\skcanvas.cpp:2770]
~~Dr.M~~ Note: #19 cc.dll!cc::DrawingDisplayItem::Raster [cc\playback\drawing_display_item.cc:51]
~~Dr.M~~ Note: #20 cc.dll!cc::DisplayItemList::Raster [cc\playback\display_item_list.cc:107]
~~Dr.M~~ Note: #21 cc.dll!cc::DisplayListRasterSource::RasterCommon [cc\playback\display_list_raster_source.cc:122]
~~Dr.M~~ Note: #22 cc.dll!cc::DisplayListRasterSource::PlaybackToCanvas [cc\playback\display_list_raster_source.cc:100]
~~Dr.M~~ Note: #23 cc.dll!cc::TileTaskWorkerPool::PlaybackToMemory [cc\raster\tile_task_worker_pool.cc:208]
~~Dr.M~~ Note: #24 cc.dll!cc::OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread [cc\raster\one_copy_tile_task_worker_pool.cc:413]
~~Dr.M~~ Note: #25 cc.dll!cc::`anonymous namespace'::RasterBufferImpl::Playback [cc\raster\one_copy_tile_task_worker_pool.cc:53]
~~Dr.M~~ Note: #26 cc.dll!cc::`anonymous namespace'::RasterTaskImpl::Raster [cc\tiles\tile_manager.cc:131]
~~Dr.M~~ Note: #27 cc.dll!cc::`anonymous namespace'::RasterTaskImpl::RunOnWorkerThread [cc\tiles\tile_manager.cc:90]
~~Dr.M~~ Note: #28 cc.dll!cc::TaskGraphRunner::RunTaskWithLockAcquired [cc\raster\task_graph_runner.cc:418]
~~Dr.M~~ Note: #29 cc.dll!cc::TaskGraphRunner::Run [cc\raster\task_graph_runner.cc:361]
~~Dr.M~~ Note: #30 base.dll!base::SimpleThread::ThreadMain [base\threading\simple_thread.cc:66]
~~Dr.M~~ Note: #31 base.dll!base::`anonymous namespace'::ThreadFunc [base\threading\platform_thread_win.cc:82]
~~Dr.M~~ Note: #32 KERNEL32.dll!BaseThreadInitThunk +0x11 (0x7570337a <KERNEL32.dll+0x1337a>)
Original issue's description:
> Parallel cache.
>
> TBR=reed@google.com
>
> BUG=skia:1330
>
> Committed: https://skia.googlesource.com/skia/+/6f2a486040cb25465990196c229feb47e668e87f
>
> Committed: https://skia.googlesource.com/skia/+/bf2988833e5a36c6b430da6fdd2cfebd0015adec
TBR=reed@google.com,mtklein@google.com,mtklein@chromium.org,herb@google.com
BUG=skia:1330
[mtklein mucking around]
NOTREECHECKS=true
Review URL: https://codereview.chromium.org/1339493002
diff --git a/include/core/SkAtomics.h b/include/core/SkAtomics.h
index 7c5294b..d31d9c6 100644
--- a/include/core/SkAtomics.h
+++ b/include/core/SkAtomics.h
@@ -30,9 +30,6 @@
T sk_atomic_fetch_add(T*, T, sk_memory_order = sk_memory_order_seq_cst);
template <typename T>
-T sk_atomic_fetch_sub(T*, T, sk_memory_order = sk_memory_order_seq_cst);
-
-template <typename T>
bool sk_atomic_compare_exchange(T*, T* expected, T desired,
sk_memory_order success = sk_memory_order_seq_cst,
sk_memory_order failure = sk_memory_order_seq_cst);
@@ -61,10 +58,6 @@
return sk_atomic_fetch_add(&fVal, val, mo);
}
- T fetch_sub(const T& val, sk_memory_order mo = sk_memory_order_seq_cst) {
- return sk_atomic_fetch_sub(&fVal, val, mo);
- }
-
bool compare_exchange(T* expected, const T& desired,
sk_memory_order success = sk_memory_order_seq_cst,
sk_memory_order failure = sk_memory_order_seq_cst) {
diff --git a/include/ports/SkAtomics_atomic.h b/include/ports/SkAtomics_atomic.h
index 64ee823..ddbf7c3 100644
--- a/include/ports/SkAtomics_atomic.h
+++ b/include/ports/SkAtomics_atomic.h
@@ -32,12 +32,6 @@
}
template <typename T>
-T sk_atomic_fetch_sub(T* ptr, T val, sk_memory_order mo) {
- // All values of mo are valid.
- return __atomic_fetch_sub(ptr, val, mo);
-}
-
-template <typename T>
bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired,
sk_memory_order success,
sk_memory_order failure) {
diff --git a/include/ports/SkAtomics_std.h b/include/ports/SkAtomics_std.h
index 163efb7..4c26858 100644
--- a/include/ports/SkAtomics_std.h
+++ b/include/ports/SkAtomics_std.h
@@ -39,13 +39,6 @@
}
template <typename T>
-T sk_atomic_fetch_sub(T* ptr, T val, sk_memory_order mo) {
- // All values of mo are valid.
- std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr);
- return std::atomic_fetch_sub_explicit(ap, val, (std::memory_order)mo);
-}
-
-template <typename T>
bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired,
sk_memory_order success,
sk_memory_order failure) {
diff --git a/include/ports/SkAtomics_sync.h b/include/ports/SkAtomics_sync.h
index 02b1e58..7ca0b46 100644
--- a/include/ports/SkAtomics_sync.h
+++ b/include/ports/SkAtomics_sync.h
@@ -46,11 +46,6 @@
}
template <typename T>
-T sk_atomic_fetch_sub(T* ptr, T val, sk_memory_order) {
- return __sync_fetch_and_sub(ptr, val);
-}
-
-template <typename T>
bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired, sk_memory_order, sk_memory_order) {
T prev = __sync_val_compare_and_swap(ptr, *expected, desired);
if (prev == *expected) {
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index dbdf6f7..d2bdd81 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -1476,12 +1476,14 @@
bounds = &storage;
}
- uint8_t*aa = (uint8_t*)state.fCache->findImage(glyph);
+ uint8_t* aa = (uint8_t*)glyph.fImage;
if (nullptr == aa) {
- return; // can't rasterize glyph
+ aa = (uint8_t*)state.fCache->findImage(glyph);
+ if (nullptr == aa) {
+ return; // can't rasterize glyph
+ }
}
-
mask.fRowBytes = glyph.rowBytes();
mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
mask.fImage = aa;
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 1020882..c747995 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -47,8 +47,6 @@
uint8_t fMaskFormat;
int8_t fRsbDelta, fLsbDelta; // used by auto-kerning
int8_t fForceBW;
- mutable bool fImageIsSet;
- mutable bool fPathIsSet;
void initWithGlyphID(uint32_t glyph_id) {
this->initCommon(MakeID(glyph_id));
@@ -137,8 +135,6 @@
fPath = nullptr;
fMaskFormat = MASK_FORMAT_UNKNOWN;
fForceBW = 0;
- fImageIsSet = false;
- fPathIsSet = false;
}
static unsigned ID2Code(uint32_t id) {
diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp
index 6112204..9bee4e5 100644
--- a/src/core/SkGlyphCache.cpp
+++ b/src/core/SkGlyphCache.cpp
@@ -8,7 +8,6 @@
#include "SkGlyphCache.h"
#include "SkGlyphCache_Globals.h"
#include "SkGraphics.h"
-#include "SkOnce.h"
#include "SkOncePtr.h"
#include "SkPath.h"
#include "SkTemplates.h"
@@ -43,90 +42,42 @@
#define kMinAllocAmount ((sizeof(SkGlyph) + kMinGlyphImageSize) * kMinGlyphCount)
SkGlyphCache::SkGlyphCache(SkTypeface* typeface, const SkDescriptor* desc, SkScalerContext* ctx)
- : fNext(nullptr)
- , fPrev(nullptr)
- , fDesc(desc->copy())
- , fRefCount(0)
- , fGlyphAlloc(kMinAllocAmount)
- , fMemoryUsed(sizeof(*this))
+ : fDesc(desc->copy())
, fScalerContext(ctx)
- , fAuxProcList(nullptr) {
+ , fGlyphAlloc(kMinAllocAmount) {
SkASSERT(typeface);
SkASSERT(desc);
SkASSERT(ctx);
+ fPrev = fNext = nullptr;
+
fScalerContext->getFontMetrics(&fFontMetrics);
+
+ fMemoryUsed = sizeof(*this);
+
+ fAuxProcList = nullptr;
}
SkGlyphCache::~SkGlyphCache() {
fGlyphMap.foreach ([](SkGlyph* g) { delete g->fPath; });
SkDescriptor::Free(fDesc);
delete fScalerContext;
- AuxProcRec* rec = fAuxProcList;
- while (rec) {
- rec->fProc(rec->fData);
- AuxProcRec* next = rec->fNext;
- delete rec;
- rec = next;
- }
-}
-
-void SkGlyphCache::increaseMemoryUsed(size_t used) {
- fMemoryUsed += used;
- get_globals().increaseTotalMemoryUsed(used);
-}
-
-SkGlyphCache::CharGlyphRec
-SkGlyphCache::PackedUnicharIDtoCharGlyphRec(PackedUnicharID packedUnicharID) {
- SkFixed x = SkGlyph::SubToFixed(SkGlyph::ID2SubX(packedUnicharID));
- SkFixed y = SkGlyph::SubToFixed(SkGlyph::ID2SubY(packedUnicharID));
- SkUnichar unichar = SkGlyph::ID2Code(packedUnicharID);
-
- SkAutoMutexAcquire lock(fScalerMutex);
- PackedGlyphID packedGlyphID = SkGlyph::MakeID(fScalerContext->charToGlyphID(unichar), x, y);
-
- return {packedUnicharID, packedGlyphID};
+ this->invokeAndRemoveAuxProcs();
}
SkGlyphCache::CharGlyphRec* SkGlyphCache::getCharGlyphRec(PackedUnicharID packedUnicharID) {
if (nullptr == fPackedUnicharIDToPackedGlyphID.get()) {
- fMapMutex.releaseShared();
-
- // Add the map only if there is a call for char -> glyph mapping.
- {
- SkAutoTAcquire<SkSharedMutex> lock(fMapMutex);
-
- // Now that the cache is locked exclusively, make sure no one added this array
- // while unlocked.
- if (nullptr == fPackedUnicharIDToPackedGlyphID.get()) {
- // Allocate the array.
- fPackedUnicharIDToPackedGlyphID.reset(new PackedUnicharIDToPackedGlyphIDMap);
- }
-
- fPackedUnicharIDToPackedGlyphID->set(PackedUnicharIDtoCharGlyphRec(packedUnicharID));
+ // Allocate the array.
+ fPackedUnicharIDToPackedGlyphID.reset(kHashCount);
+ // Initialize array to map character and position with the impossible glyph ID. This
+ // represents no mapping.
+ for (int i = 0; i <kHashCount; ++i) {
+ fPackedUnicharIDToPackedGlyphID[i].fPackedUnicharID = SkGlyph::kImpossibleID;
+ fPackedUnicharIDToPackedGlyphID[i].fPackedGlyphID = 0;
}
- fMapMutex.acquireShared();
-
- return fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
}
- CharGlyphRec* answer = fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
- if (nullptr == answer) {
- fMapMutex.releaseShared();
- // Add a new char -> glyph mapping.
- {
- SkAutoTAcquire<SkSharedMutex> lock(fMapMutex);
- answer = fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
- if (nullptr == answer) {
- fPackedUnicharIDToPackedGlyphID->set(
- PackedUnicharIDtoCharGlyphRec(packedUnicharID));
- }
- }
- fMapMutex.acquireShared();
- return fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
- }
-
- return answer;
+ return &fPackedUnicharIDToPackedGlyphID[SkChecksum::CheapMix(packedUnicharID) & kHashMask];
}
///////////////////////////////////////////////////////////////////////////////
@@ -141,11 +92,15 @@
VALIDATE();
PackedUnicharID packedUnicharID = SkGlyph::MakeID(charCode);
const CharGlyphRec& rec = *this->getCharGlyphRec(packedUnicharID);
- return SkGlyph::ID2Code(rec.fPackedGlyphID);
+
+ if (rec.fPackedUnicharID == packedUnicharID) {
+ return SkGlyph::ID2Code(rec.fPackedGlyphID);
+ } else {
+ return fScalerContext->charToGlyphID(charCode);
+ }
}
SkUnichar SkGlyphCache::glyphToUnichar(uint16_t glyphID) {
- SkAutoMutexAcquire lock(fScalerMutex);
return fScalerContext->glyphIDToChar(glyphID);
}
@@ -159,19 +114,19 @@
///////////////////////////////////////////////////////////////////////////////
-SkGlyph* SkGlyphCache::lookupByChar(SkUnichar charCode, SkFixed x, SkFixed y) {
- PackedUnicharID targetUnicharID = SkGlyph::MakeID(charCode, x, y);
- CharGlyphRec* rec = this->getCharGlyphRec(targetUnicharID);
- PackedGlyphID packedGlyphID = rec->fPackedGlyphID;
-
- return this->lookupByPackedGlyphID(packedGlyphID);
-}
-
const SkGlyph& SkGlyphCache::getUnicharAdvance(SkUnichar charCode) {
VALIDATE();
return *this->lookupByChar(charCode);
}
+const SkGlyph& SkGlyphCache::getGlyphIDAdvance(uint16_t glyphID) {
+ VALIDATE();
+ PackedGlyphID packedGlyphID = SkGlyph::MakeID(glyphID);
+ return *this->lookupByPackedGlyphID(packedGlyphID);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode) {
VALIDATE();
return *this->lookupByChar(charCode);
@@ -182,49 +137,6 @@
return *this->lookupByChar(charCode, x, y);
}
-///////////////////////////////////////////////////////////////////////////////
-SkGlyph* SkGlyphCache::allocateNewGlyph(PackedGlyphID packedGlyphID) {
- SkGlyph* glyphPtr;
- {
- fMapMutex.releaseShared();
- {
- SkAutoTAcquire<SkSharedMutex> mapLock(fMapMutex);
- glyphPtr = fGlyphMap.find(packedGlyphID);
- if (nullptr == glyphPtr) {
- SkGlyph glyph;
- glyph.initGlyphFromCombinedID(packedGlyphID);
- {
- SkAutoMutexAcquire lock(fScalerMutex);
- fScalerContext->getMetrics(&glyph);
- this->increaseMemoryUsed(sizeof(SkGlyph));
- glyphPtr = fGlyphMap.set(glyph);
- } // drop scaler lock
-
- }
- } // drop map lock
- fMapMutex.acquireShared();
- glyphPtr = fGlyphMap.find(packedGlyphID);
- }
-
- SkASSERT(glyphPtr->fID != SkGlyph::kImpossibleID);
- return glyphPtr;
-}
-
-SkGlyph* SkGlyphCache::lookupByPackedGlyphID(PackedGlyphID packedGlyphID) {
- SkGlyph* glyph = fGlyphMap.find(packedGlyphID);
-
- if (nullptr == glyph) {
- glyph = this->allocateNewGlyph(packedGlyphID);
- }
- return glyph;
-}
-
-const SkGlyph& SkGlyphCache::getGlyphIDAdvance(uint16_t glyphID) {
- VALIDATE();
- PackedGlyphID packedGlyphID = SkGlyph::MakeID(glyphID);
- return *this->lookupByPackedGlyphID(packedGlyphID);
-}
-
const SkGlyph& SkGlyphCache::getGlyphIDMetrics(uint16_t glyphID) {
VALIDATE();
PackedGlyphID packedGlyphID = SkGlyph::MakeID(glyphID);
@@ -237,46 +149,74 @@
return *this->lookupByPackedGlyphID(packedGlyphID);
}
-///////////////////////////////////////////////////////////////////////////////
-
-void SkGlyphCache::OnceFillInImage(GlyphAndCache gc) {
- SkGlyphCache* cache = gc.cache;
- const SkGlyph* glyph = gc.glyph;
- cache->fScalerMutex.assertHeld();
- if (glyph->fWidth > 0 && glyph->fWidth < kMaxGlyphWidth) {
- size_t size = glyph->computeImageSize();
- sk_atomic_store(&const_cast<SkGlyph*>(glyph)->fImage,
- cache->fGlyphAlloc.alloc(size, SkChunkAlloc::kReturnNil_AllocFailType),
- sk_memory_order_relaxed);
- if (glyph->fImage != nullptr) {
- cache->fScalerContext->getImage(*glyph);
- cache->increaseMemoryUsed(size);
- }
+SkGlyph* SkGlyphCache::lookupByChar(SkUnichar charCode, SkFixed x, SkFixed y) {
+ PackedUnicharID id = SkGlyph::MakeID(charCode, x, y);
+ CharGlyphRec* rec = this->getCharGlyphRec(id);
+ if (rec->fPackedUnicharID != id) {
+ // this ID is based on the UniChar
+ rec->fPackedUnicharID = id;
+ // this ID is based on the glyph index
+ PackedGlyphID combinedID = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode), x, y);
+ rec->fPackedGlyphID = combinedID;
+ return this->lookupByPackedGlyphID(combinedID);
+ } else {
+ return this->lookupByPackedGlyphID(rec->fPackedGlyphID);
}
}
+SkGlyph* SkGlyphCache::lookupByPackedGlyphID(PackedGlyphID packedGlyphID) {
+ SkGlyph* glyph = fGlyphMap.find(packedGlyphID);
+ if (nullptr == glyph) {
+ glyph = this->allocateNewGlyph(packedGlyphID);
+ }
+ return glyph;
+}
+
+SkGlyph* SkGlyphCache::allocateNewGlyph(PackedGlyphID packedGlyphID) {
+ fMemoryUsed += sizeof(SkGlyph);
+
+ SkGlyph* glyphPtr;
+ {
+ SkGlyph glyph;
+ glyph.initGlyphFromCombinedID(packedGlyphID);
+ glyphPtr = fGlyphMap.set(glyph);
+ }
+ fScalerContext->getMetrics(glyphPtr);
+
+ SkASSERT(glyphPtr->fID != SkGlyph::kImpossibleID);
+ return glyphPtr;
+}
+
const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
- SkOnce<SkMutex, GlyphAndCache>(
- &glyph.fImageIsSet, &fScalerMutex, &SkGlyphCache::OnceFillInImage, {this, &glyph});
- return sk_atomic_load(&glyph.fImage, sk_memory_order_seq_cst);
-}
-
-void SkGlyphCache::OnceFillInPath(GlyphAndCache gc) {
- SkGlyphCache* cache = gc.cache;
- const SkGlyph* glyph = gc.glyph;
- cache->fScalerMutex.assertHeld();
- if (glyph->fWidth > 0) {
- sk_atomic_store(&const_cast<SkGlyph*>(glyph)->fPath, new SkPath, sk_memory_order_relaxed);
- cache->fScalerContext->getPath(*glyph, glyph->fPath);
- size_t size = sizeof(SkPath) + glyph->fPath->countPoints() * sizeof(SkPoint);
- cache->increaseMemoryUsed(size);
+ if (glyph.fWidth > 0 && glyph.fWidth < kMaxGlyphWidth) {
+ if (nullptr == glyph.fImage) {
+ size_t size = glyph.computeImageSize();
+ const_cast<SkGlyph&>(glyph).fImage = fGlyphAlloc.alloc(size,
+ SkChunkAlloc::kReturnNil_AllocFailType);
+ // check that alloc() actually succeeded
+ if (glyph.fImage) {
+ fScalerContext->getImage(glyph);
+ // TODO: the scaler may have changed the maskformat during
+ // getImage (e.g. from AA or LCD to BW) which means we may have
+ // overallocated the buffer. Check if the new computedImageSize
+ // is smaller, and if so, strink the alloc size in fImageAlloc.
+ fMemoryUsed += size;
+ }
+ }
}
+ return glyph.fImage;
}
const SkPath* SkGlyphCache::findPath(const SkGlyph& glyph) {
- SkOnce<SkMutex, GlyphAndCache>(
- &glyph.fPathIsSet, &fScalerMutex, &SkGlyphCache::OnceFillInPath, {this, &glyph});
- return sk_atomic_load(&glyph.fPath, sk_memory_order_seq_cst);
+ if (glyph.fWidth) {
+ if (glyph.fPath == nullptr) {
+ const_cast<SkGlyph&>(glyph).fPath = new SkPath;
+ fScalerContext->getPath(glyph, glyph.fPath);
+ fMemoryUsed += sizeof(SkPath) +
+ glyph.fPath->countPoints() * sizeof(SkPoint);
+ }
+ }
+ return glyph.fPath;
}
void SkGlyphCache::dump() const {
@@ -289,22 +229,18 @@
face->getFamilyName(&name);
SkString msg;
- msg.printf(
- "cache typeface:%x %25s:%d size:%2g [%g %g %g %g] "
- "lum:%02X devG:%d pntG:%d cntr:%d glyphs:%3d",
- face->uniqueID(), name.c_str(), face->style(), rec.fTextSize,
- matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewX],
- matrix[SkMatrix::kMSkewY], matrix[SkMatrix::kMScaleY],
- rec.fLumBits & 0xFF, rec.fDeviceGamma, rec.fPaintGamma, rec.fContrast,
- fGlyphMap.count());
+ msg.printf("cache typeface:%x %25s:%d size:%2g [%g %g %g %g] lum:%02X devG:%d pntG:%d cntr:%d glyphs:%3d",
+ face->uniqueID(), name.c_str(), face->style(), rec.fTextSize,
+ matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewX],
+ matrix[SkMatrix::kMSkewY], matrix[SkMatrix::kMScaleY],
+ rec.fLumBits & 0xFF, rec.fDeviceGamma, rec.fPaintGamma, rec.fContrast,
+ fGlyphMap.count());
SkDebugf("%s\n", msg.c_str());
}
///////////////////////////////////////////////////////////////////////////////
bool SkGlyphCache::getAuxProcData(void (*proc)(void*), void** dataPtr) const {
- // Borrow the fScalerMutex to protect the AuxProc list.
- SkAutoMutexAcquire lock(fScalerMutex);
const AuxProcRec* rec = fAuxProcList;
while (rec) {
if (rec->fProc == proc) {
@@ -323,8 +259,6 @@
return;
}
- // Borrow the fScalerMutex to protect the AuxProc linked list.
- SkAutoMutexAcquire lock(fScalerMutex);
AuxProcRec* rec = fAuxProcList;
while (rec) {
if (rec->fProc == proc) {
@@ -341,9 +275,27 @@
fAuxProcList = rec;
}
+void SkGlyphCache::invokeAndRemoveAuxProcs() {
+ AuxProcRec* rec = fAuxProcList;
+ while (rec) {
+ rec->fProc(rec->fData);
+ AuxProcRec* next = rec->fNext;
+ delete rec;
+ rec = next;
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-typedef SkAutoTAcquire<SkSpinlock> AutoAcquire;
+
+class AutoAcquire {
+public:
+ AutoAcquire(SkSpinlock& lock) : fLock(lock) { fLock.acquire(); }
+ ~AutoAcquire() { fLock.release(); }
+private:
+ SkSpinlock& fLock;
+};
size_t SkGlyphCache_Globals::setCacheSizeLimit(size_t newLimit) {
static const size_t minLimit = 256 * 1024;
@@ -374,7 +326,7 @@
void SkGlyphCache_Globals::purgeAll() {
AutoAcquire ac(fLock);
- this->internalPurge(fTotalMemoryUsed.load());
+ this->internalPurge(fTotalMemoryUsed);
}
/* This guy calls the visitor from within the mutext lock, so the visitor
@@ -383,8 +335,10 @@
- try to acquire the mutext again
- call a fontscaler (which might call into the cache)
*/
-SkGlyphCache* SkGlyphCache::VisitCache(
- SkTypeface* typeface, const SkDescriptor* desc, VisitProc proc, void* context) {
+SkGlyphCache* SkGlyphCache::VisitCache(SkTypeface* typeface,
+ const SkDescriptor* desc,
+ bool (*proc)(const SkGlyphCache*, void*),
+ void* context) {
if (!typeface) {
typeface = SkTypeface::GetDefaultTypeface();
}
@@ -400,15 +354,11 @@
for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
if (cache->fDesc->equals(*desc)) {
- globals.internalMoveToHead(cache);
- cache->fMapMutex.acquireShared();
+ globals.internalDetachCache(cache);
if (!proc(cache, context)) {
- cache->fMapMutex.releaseShared();
- return nullptr;
+ globals.internalAttachCacheToHead(cache);
+ cache = nullptr;
}
- // The caller will take reference on this SkGlyphCache, and the corresponding
- // Attach call will decrement the reference.
- cache->fRefCount += 1;
return cache;
}
}
@@ -421,43 +371,28 @@
// pass true the first time, to notice if the scalercontext failed,
// so we can try the purge.
SkScalerContext* ctx = typeface->createScalerContext(desc, true);
- if (nullptr == ctx) {
+ if (!ctx) {
get_globals().purgeAll();
ctx = typeface->createScalerContext(desc, false);
SkASSERT(ctx);
}
-
cache = new SkGlyphCache(typeface, desc, ctx);
}
- AutoAcquire ac(globals.fLock);
- globals.internalAttachCacheToHead(cache);
+ AutoValidate av(cache);
- cache->fMapMutex.acquireShared();
if (!proc(cache, context)) { // need to reattach
- cache->fMapMutex.releaseShared();
- return nullptr;
+ globals.attachCacheToHead(cache);
+ cache = nullptr;
}
- // The caller will take reference on this SkGlyphCache, and the corresponding
- // Attach call will decrement the reference.
- cache->fRefCount += 1;
return cache;
}
void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
SkASSERT(cache);
- cache->fMapMutex.releaseShared();
- SkGlyphCache_Globals& globals = get_globals();
- AutoAcquire ac(globals.fLock);
- globals.validate();
- cache->validate();
+ SkASSERT(cache->fNext == nullptr);
- // Unref and delete if no longer in the LRU list.
- cache->fRefCount -= 1;
- if (cache->fRefCount == 0) {
- delete cache;
- }
- globals.internalPurge();
+ get_globals().attachCacheToHead(cache);
}
static void dump_visitor(const SkGlyphCache& cache, void* context) {
@@ -532,17 +467,14 @@
///////////////////////////////////////////////////////////////////////////////
-void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
- this->internalPurge();
- fCacheCount += 1;
- cache->fRefCount += 1;
- // Access to cache->fMemoryUsed is single threaded until internalMoveToHead.
- fTotalMemoryUsed.fetch_add(cache->fMemoryUsed);
-
- this->internalMoveToHead(cache);
+void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
+ AutoAcquire ac(fLock);
this->validate();
cache->validate();
+
+ this->internalAttachCacheToHead(cache);
+ this->internalPurge();
}
SkGlyphCache* SkGlyphCache_Globals::internalGetTail() const {
@@ -559,13 +491,13 @@
this->validate();
size_t bytesNeeded = 0;
- if (fTotalMemoryUsed.load() > fCacheSizeLimit) {
- bytesNeeded = fTotalMemoryUsed.load() - fCacheSizeLimit;
+ if (fTotalMemoryUsed > fCacheSizeLimit) {
+ bytesNeeded = fTotalMemoryUsed - fCacheSizeLimit;
}
bytesNeeded = SkTMax(bytesNeeded, minBytesNeeded);
if (bytesNeeded) {
// no small purges!
- bytesNeeded = SkTMax(bytesNeeded, fTotalMemoryUsed.load() >> 2);
+ bytesNeeded = SkTMax(bytesNeeded, fTotalMemoryUsed >> 2);
}
int countNeeded = 0;
@@ -591,10 +523,9 @@
SkGlyphCache* prev = cache->fPrev;
bytesFreed += cache->fMemoryUsed;
countFreed += 1;
+
this->internalDetachCache(cache);
- if (0 == cache->fRefCount) {
- delete cache;
- }
+ delete cache;
cache = prev;
}
@@ -610,50 +541,34 @@
return bytesFreed;
}
-void SkGlyphCache_Globals::internalMoveToHead(SkGlyphCache *cache) {
- if (cache != fHead) {
- if (cache->fPrev) {
- cache->fPrev->fNext = cache->fNext;
- }
- if (cache->fNext) {
- cache->fNext->fPrev = cache->fPrev;
- }
- cache->fNext = nullptr;
- cache->fPrev = nullptr;
- if (fHead) {
- fHead->fPrev = cache;
- cache->fNext = fHead;
- }
- fHead = cache;
+void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
+ SkASSERT(nullptr == cache->fPrev && nullptr == cache->fNext);
+ if (fHead) {
+ fHead->fPrev = cache;
+ cache->fNext = fHead;
}
+ fHead = cache;
+
+ fCacheCount += 1;
+ fTotalMemoryUsed += cache->fMemoryUsed;
}
void SkGlyphCache_Globals::internalDetachCache(SkGlyphCache* cache) {
+ SkASSERT(fCacheCount > 0);
fCacheCount -= 1;
- fTotalMemoryUsed.fetch_sub(cache->fMemoryUsed);
+ fTotalMemoryUsed -= cache->fMemoryUsed;
if (cache->fPrev) {
cache->fPrev->fNext = cache->fNext;
} else {
- // If cache->fPrev == nullptr then this is the head node.
fHead = cache->fNext;
- if (fHead != nullptr) {
- fHead->fPrev = nullptr;
- }
}
if (cache->fNext) {
cache->fNext->fPrev = cache->fPrev;
- } else {
- // If cache->fNext == nullptr then this is the last node.
- if (cache->fPrev != nullptr) {
- cache->fPrev->fNext = nullptr;
- }
}
cache->fPrev = cache->fNext = nullptr;
- cache->fRefCount -= 1;
}
-
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_DEBUG
@@ -672,16 +587,20 @@
}
void SkGlyphCache_Globals::validate() const {
+ size_t computedBytes = 0;
int computedCount = 0;
- SkGlyphCache* head = fHead;
+ const SkGlyphCache* head = fHead;
while (head != nullptr) {
+ computedBytes += head->fMemoryUsed;
computedCount += 1;
head = head->fNext;
}
SkASSERTF(fCacheCount == computedCount, "fCacheCount: %d, computedCount: %d", fCacheCount,
computedCount);
+ SkASSERTF(fTotalMemoryUsed == computedBytes, "fTotalMemoryUsed: %d, computedBytes: %d",
+ fTotalMemoryUsed, computedBytes);
}
#endif
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index cf64527..4eb6b5b 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -11,11 +11,8 @@
#include "SkChunkAlloc.h"
#include "SkDescriptor.h"
#include "SkGlyph.h"
-#include "SkMutex.h"
#include "SkTHash.h"
#include "SkScalerContext.h"
-#include "SkSharedMutex.h"
-#include "SkSpinlock.h"
#include "SkTemplates.h"
#include "SkTDArray.h"
@@ -122,23 +119,12 @@
SkScalerContext* getScalerContext() const { return fScalerContext; }
- struct GlyphAndCache {
- SkGlyphCache* cache;
- const SkGlyph* glyph;
- };
-
- static void OnceFillInImage(GlyphAndCache gc);
-
- static void OnceFillInPath(GlyphAndCache gc);
-
- typedef bool (*VisitProc)(const SkGlyphCache*, void*);
-
/** Find a matching cache entry, and call proc() with it. If none is found create a new one.
If the proc() returns true, detach the cache and return it, otherwise leave it and return
nullptr.
*/
static SkGlyphCache* VisitCache(SkTypeface*, const SkDescriptor* desc,
- VisitProc proc,
+ bool (*proc)(const SkGlyphCache*, void*),
void* context);
/** Given a strike that was returned by either VisitCache() or DetachCache() add it back into
@@ -195,21 +181,18 @@
private:
friend class SkGlyphCache_Globals;
+ enum {
+ kHashBits = 8,
+ kHashCount = 1 << kHashBits,
+ kHashMask = kHashCount - 1
+ };
+
typedef uint32_t PackedGlyphID; // glyph-index + subpixel-pos
typedef uint32_t PackedUnicharID; // unichar + subpixel-pos
struct CharGlyphRec {
- class HashTraits {
- public:
- static PackedUnicharID GetKey(const CharGlyphRec& rec) {
- return rec.fPackedUnicharID;
- }
- static uint32_t Hash(PackedUnicharID unicharID) {
- return SkChecksum::CheapMix(unicharID);
- }
- };
- PackedUnicharID fPackedUnicharID;
- PackedGlyphID fPackedGlyphID;
+ PackedUnicharID fPackedUnicharID;
+ PackedGlyphID fPackedGlyphID;
};
struct AuxProcRec {
@@ -222,9 +205,6 @@
SkGlyphCache(SkTypeface*, const SkDescriptor*, SkScalerContext*);
~SkGlyphCache();
- // Increase the memory used keeping the cache and the global size in sync.
- void increaseMemoryUsed(size_t used);
-
// Return the SkGlyph* associated with MakeID. The id parameter is the
// combined glyph/x/y id generated by MakeID. If it is just a glyph id
// then x and y are assumed to be zero.
@@ -236,45 +216,32 @@
// Return a new SkGlyph for the glyph ID and subpixel position id.
SkGlyph* allocateNewGlyph(PackedGlyphID packedGlyphID);
- // Add the full metrics to an existing glyph.
- void addFullMetrics(SkGlyph* glyph);
-
static bool DetachProc(const SkGlyphCache*, void*) { return true; }
- CharGlyphRec PackedUnicharIDtoCharGlyphRec(PackedUnicharID packedUnicharID);
-
// The id arg is a combined id generated by MakeID.
CharGlyphRec* getCharGlyphRec(PackedUnicharID id);
+ void invokeAndRemoveAuxProcs();
+
inline static SkGlyphCache* FindTail(SkGlyphCache* head);
- // The following are protected by the SkGlyphCache_Globals fLock mutex.
- // Note: the following fields are protected by a mutex in a different class.
SkGlyphCache* fNext;
SkGlyphCache* fPrev;
SkDescriptor* const fDesc;
+ SkScalerContext* const fScalerContext;
SkPaint::FontMetrics fFontMetrics;
- int fRefCount;
- // The following fields are protected by fMapMutex.
- mutable SkSharedMutex fMapMutex;
// Map from a combined GlyphID and sub-pixel position to a SkGlyph.
SkTHashTable<SkGlyph, PackedGlyphID, SkGlyph::HashTraits> fGlyphMap;
+
SkChunkAlloc fGlyphAlloc;
- typedef SkTHashTable<CharGlyphRec, PackedUnicharID, CharGlyphRec::HashTraits>
- PackedUnicharIDToPackedGlyphIDMap;
- SkAutoTDelete<PackedUnicharIDToPackedGlyphIDMap> fPackedUnicharIDToPackedGlyphID;
+
+ SkAutoTArray<CharGlyphRec> fPackedUnicharIDToPackedGlyphID;
+
// used to track (approx) how much ram is tied-up in this cache
size_t fMemoryUsed;
- // The FScalerMutex protects the following fields. It is mainly used to ensure single-threaded
- // access to the font scaler, but it also protects the fAuxProcList.
- mutable SkMutex fScalerMutex;
- SkScalerContext* const fScalerContext;
AuxProcRec* fAuxProcList;
-
- // BEWARE: Mutex ordering
- // If you need to hold both fMapMutex and fScalerMutex then fMapMutex must be held first.
};
class SkAutoGlyphCacheBase {
diff --git a/src/core/SkGlyphCache_Globals.h b/src/core/SkGlyphCache_Globals.h
index 3736ace..e1825a2 100644
--- a/src/core/SkGlyphCache_Globals.h
+++ b/src/core/SkGlyphCache_Globals.h
@@ -26,9 +26,8 @@
class SkGlyphCache_Globals {
public:
SkGlyphCache_Globals() {
-
fHead = nullptr;
- fTotalMemoryUsed.store(0);
+ fTotalMemoryUsed = 0;
fCacheSizeLimit = SK_DEFAULT_FONT_CACHE_LIMIT;
fCacheCount = 0;
fCacheCountLimit = SK_DEFAULT_FONT_CACHE_COUNT_LIMIT;
@@ -48,8 +47,7 @@
SkGlyphCache* internalGetHead() const { return fHead; }
SkGlyphCache* internalGetTail() const;
- size_t getTotalMemoryUsed() const { return fTotalMemoryUsed.load(); }
- void increaseTotalMemoryUsed(size_t increase) { fTotalMemoryUsed.fetch_add(increase);}
+ size_t getTotalMemoryUsed() const { return fTotalMemoryUsed; }
int getCacheCountUsed() const { return fCacheCount; }
#ifdef SK_DEBUG
@@ -68,30 +66,29 @@
// or count limit.
bool isOverBudget() const {
return fCacheCount > fCacheCountLimit ||
- fTotalMemoryUsed.load() > fCacheSizeLimit;
+ fTotalMemoryUsed > fCacheSizeLimit;
}
void purgeAll(); // does not change budget
// call when a glyphcache is available for caching (i.e. not in use)
- void internalAttachCacheToHead(SkGlyphCache*);
+ void attachCacheToHead(SkGlyphCache*);
// can only be called when the mutex is already held
- void internalMoveToHead(SkGlyphCache *);
+ void internalDetachCache(SkGlyphCache*);
+ void internalAttachCacheToHead(SkGlyphCache*);
+
+private:
+ SkGlyphCache* fHead;
+ size_t fTotalMemoryUsed;
+ size_t fCacheSizeLimit;
+ int32_t fCacheCountLimit;
+ int32_t fCacheCount;
// Checkout budgets, modulated by the specified min-bytes-needed-to-purge,
// and attempt to purge caches to match.
// Returns number of bytes freed.
- void internalDetachCache(SkGlyphCache* cache);
size_t internalPurge(size_t minBytesNeeded = 0);
-
-private:
- SkGlyphCache* fHead;
- SkAtomic<size_t> fTotalMemoryUsed;
- size_t fCacheSizeLimit;
- int32_t fCacheCountLimit;
- int32_t fCacheCount;
-
};
#endif
