skia::textlayout::ParagraphCache Class Reference

#include <ParagraphCache.h>

Classes
struct	Entry

Public Member Functions
	ParagraphCache ()
	~ParagraphCache ()
void	abandon ()
void	reset ()
bool	updateParagraph (ParagraphImpl *paragraph)
bool	findParagraph (ParagraphImpl *paragraph)
void	setChecker (std::function< void(ParagraphImpl *impl, const char *, bool)> checker)
void	printStatistics ()
void	turnOn (bool value)
int	count ()
bool	isPossiblyTextEditing (ParagraphImpl *paragraph)

Detailed Description

Definition at line 18 of file ParagraphCache.h.

Constructor & Destructor Documentation

ParagraphCache()

skia::textlayout::ParagraphCache::ParagraphCache

(

)

Definition at line 241 of file ParagraphCache.cpp.

    : fChecker([](ParagraphImpl* impl, const char*, bool){ })
    , fLRUCacheMap(kMaxEntries)
    , fCacheIsOn(true)
    , fLastCachedValue(nullptr)
#ifdef PARAGRAPH_CACHE_STATS
    , fTotalRequests(0)
    , fCacheMisses(0)
    , fHashMisses(0)
#endif
{ }

~ParagraphCache()

skia::textlayout::ParagraphCache::~ParagraphCache

(

)

Definition at line 253 of file ParagraphCache.cpp.

{ }

Member Function Documentation

abandon()

void skia::textlayout::ParagraphCache::abandon

(

)

Definition at line 285 of file ParagraphCache.cpp.

                             {
    this->reset();
}

count()

int skia::textlayout::ParagraphCache::count ( )

inline

Definition at line 34 of file ParagraphCache.h.

{ return fLRUCacheMap.count(); }

findParagraph()

bool skia::textlayout::ParagraphCache::findParagraph

(

ParagraphImpl *

paragraph

)

Definition at line 300 of file ParagraphCache.cpp.

                                                           {
    if (!fCacheIsOn) {
        return false;
    }
#ifdef PARAGRAPH_CACHE_STATS
    ++fTotalRequests;
#endif
    SkAutoMutexExclusive lock(fParagraphMutex);
    ParagraphCacheKey key(paragraph);
    std::unique_ptr<Entry>* entry = fLRUCacheMap.find(key);
 
    if (!entry) {
        // We have a cache miss
#ifdef PARAGRAPH_CACHE_STATS
        ++fCacheMisses;
#endif
        fChecker(paragraph, "missingParagraph", true);
        return false;
    }
    updateTo(paragraph, entry->get());
    fChecker(paragraph, "foundParagraph", true);
    return true;
}

isPossiblyTextEditing()

bool skia::textlayout::ParagraphCache::isPossiblyTextEditing

(

ParagraphImpl *

paragraph

)

Definition at line 354 of file ParagraphCache.cpp.

                                                                   {
    if (fLastCachedValue == nullptr) {
        return false;
    }
 
    auto& lastText = fLastCachedValue->fKey.text();
    auto& text = paragraph->fText;
 
    if ((lastText.size() < NOCACHE_PREFIX_LENGTH) || (text.size() < NOCACHE_PREFIX_LENGTH)) {
        // Either last text or the current are too short
        return false;
    }
 
    if (std::strncmp(lastText.c_str(), text.c_str(), NOCACHE_PREFIX_LENGTH) == 0) {
        // Texts have the same starts
        return true;
    }
 
    if (std::strncmp(lastText.c_str() + lastText.size() - NOCACHE_PREFIX_LENGTH, &text[text.size() - NOCACHE_PREFIX_LENGTH], NOCACHE_PREFIX_LENGTH) == 0) {
        // Texts have the same ends
        return true;
    }
 
    // It does not look like editing the text
    return false;
}

printStatistics()

void skia::textlayout::ParagraphCache::printStatistics

(

)

Definition at line 275 of file ParagraphCache.cpp.

                                     {
    SkDebugf("--- Paragraph Cache ---\n");
    SkDebugf("Total requests: %d\n", fTotalRequests);
    SkDebugf("Cache misses: %d\n", fCacheMisses);
    SkDebugf("Cache miss %%: %f\n", (fTotalRequests > 0) ? 100.f * fCacheMisses / fTotalRequests : 0.f);
    int cacheHits = fTotalRequests - fCacheMisses;
    SkDebugf("Hash miss %%: %f\n", (cacheHits > 0) ? 100.f * fHashMisses / cacheHits : 0.f);
    SkDebugf("---------------------\n");
}

reset()

void skia::textlayout::ParagraphCache::reset

(

)

Definition at line 289 of file ParagraphCache.cpp.

                           {
    SkAutoMutexExclusive lock(fParagraphMutex);
#ifdef PARAGRAPH_CACHE_STATS
    fTotalRequests = 0;
    fCacheMisses = 0;
    fHashMisses = 0;
#endif
    fLRUCacheMap.reset();
    fLastCachedValue = nullptr;
}

setChecker()

void skia::textlayout::ParagraphCache::setChecker ( std::function< void(ParagraphImpl *impl, const char *, bool)>  checker )

inline

Definition at line 29 of file ParagraphCache.h.

                                                                                       {
        fChecker = std::move(checker);
    }

turnOn()

void skia::textlayout::ParagraphCache::turnOn ( bool  value )

inline

Definition at line 33 of file ParagraphCache.h.

{ fCacheIsOn = value; }

updateParagraph()

bool skia::textlayout::ParagraphCache::updateParagraph

(

ParagraphImpl *

paragraph

)

Definition at line 324 of file ParagraphCache.cpp.

                                                             {
    if (!fCacheIsOn) {
        return false;
    }
#ifdef PARAGRAPH_CACHE_STATS
    ++fTotalRequests;
#endif
    SkAutoMutexExclusive lock(fParagraphMutex);
 
    ParagraphCacheKey key(paragraph);
    std::unique_ptr<Entry>* entry = fLRUCacheMap.find(key);
    if (!entry) {
        // isTooMuchMemoryWasted(paragraph) not needed for now
        if (isPossiblyTextEditing(paragraph)) {
            // Skip this paragraph
            return false;
        }
        ParagraphCacheValue* value = new ParagraphCacheValue(std::move(key), paragraph);
        fLRUCacheMap.insert(value->fKey, std::make_unique<Entry>(value));
        fChecker(paragraph, "addedParagraph", true);
        fLastCachedValue = value;
        return true;
    } else {
        // We do not have to update the paragraph
        return false;
    }
}

---

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

• third_party/skia/modules/skparagraph/include/ParagraphCache.h
• third_party/skia/modules/skparagraph/src/ParagraphCache.cpp