SkResourceCache.cpp File Reference

#include "src/core/SkResourceCache.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkString.h"
#include "include/core/SkTraceMemoryDump.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkCachedData.h"
#include "src/core/SkChecksum.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkMessageBus.h"
#include "src/core/SkTHash.h"
#include <algorithm>

Go to the source code of this file.

Classes
class	SkResourceCache::Hash

Macros
#define	SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT   1024
#define	SK_DEFAULT_IMAGE_CACHE_LIMIT   (32 * 1024 * 1024)

Functions
static bool	SkShouldPostMessageToBus (const SkResourceCache::PurgeSharedIDMessage &, uint32_t)
static void	make_size_str (size_t size, SkString *str)
static SkMutex &	resource_cache_mutex ()
static SkResourceCache *	get_cache ()
static void	dump_visitor (const SkResourceCache::Rec &rec, void *)
static void	sk_trace_dump_visitor (const SkResourceCache::Rec &rec, void *context)

Variables
static bool	gDumpCacheTransactions
static SkResourceCache *	gResourceCache = nullptr

Macro Definition Documentation

SK_DEFAULT_IMAGE_CACHE_LIMIT

#define SK_DEFAULT_IMAGE_CACHE_LIMIT   (32 * 1024 * 1024)

Definition at line 52 of file SkResourceCache.cpp.

SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT

#define SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT   1024

Definition at line 48 of file SkResourceCache.cpp.

Function Documentation

dump_visitor()

static void dump_visitor ( const SkResourceCache::Rec &  rec, void *    )

static

Definition at line 591 of file SkResourceCache.cpp.

                                                               {
    SkDebugf("RC: %12s bytes %9zu  discardable %p\n",
             rec.getCategory(), rec.bytesUsed(), rec.diagnostic_only_getDiscardable());
}

get_cache()

static SkResourceCache * get_cache ( )

static

Must hold resource_cache_mutex() when calling.

Definition at line 473 of file SkResourceCache.cpp.

                                    {
    // resource_cache_mutex() is always held when this is called, so we don't need to be fancy in here.
    resource_cache_mutex().assertHeld();
    if (nullptr == gResourceCache) {
#ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
        gResourceCache = new SkResourceCache(SkDiscardableMemory::Create);
#else
        gResourceCache = new SkResourceCache(SK_DEFAULT_IMAGE_CACHE_LIMIT);
#endif
    }
    return gResourceCache;
}

make_size_str()

static void make_size_str ( size_t  size, SkString *  str  )

static

Definition at line 145 of file SkResourceCache.cpp.

                                                      {
    const char suffix[] = { 'b', 'k', 'm', 'g', 't', 0 };
    int i = 0;
    while (suffix[i] && (size > 1024)) {
        i += 1;
        size >>= 10;
    }
    str->printf("%zu%c", size, suffix[i]);
}

resource_cache_mutex()

static SkMutex & resource_cache_mutex ( )

static

Definition at line 467 of file SkResourceCache.cpp.

                                       {
    static SkMutex& mutex = *(new SkMutex);
    return mutex;
}

sk_trace_dump_visitor()

static void sk_trace_dump_visitor ( const SkResourceCache::Rec &  rec, void *  context  )

static

Definition at line 600 of file SkResourceCache.cpp.

                                                                                {
    SkTraceMemoryDump* dump = static_cast<SkTraceMemoryDump*>(context);
    SkString dumpName = SkStringPrintf("skia/sk_resource_cache/%s_%p", rec.getCategory(), &rec);
    SkDiscardableMemory* discardable = rec.diagnostic_only_getDiscardable();
    if (discardable) {
        dump->setDiscardableMemoryBacking(dumpName.c_str(), *discardable);
 
        // The discardable memory size will be calculated by dumper, but we also dump what we think
        // the size of object in memory is irrespective of whether object is live or dead.
        dump->dumpNumericValue(dumpName.c_str(), "discardable_size", "bytes", rec.bytesUsed());
    } else {
        dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", rec.bytesUsed());
        dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
    }
}

SkShouldPostMessageToBus()

static bool SkShouldPostMessageToBus ( const SkResourceCache::PurgeSharedIDMessage &  , uint32_t    )

inlinestatic

Definition at line 37 of file SkResourceCache.cpp.

                                                              {
    // SkResourceCache is typically used as a singleton and we don't label Inboxes so all messages
    // go to all inboxes.
    return true;
}

Variable Documentation

gDumpCacheTransactions

bool gDumpCacheTransactions

static

Definition at line 155 of file SkResourceCache.cpp.

gResourceCache

SkResourceCache* gResourceCache = nullptr

static

Definition at line 466 of file SkResourceCache.cpp.