MemoryCache.cpp

@@void MemoryCache::pruneDeadResourcesToSize(unsigned targetSize)

    if (m_inPruneResources)

        return;

    TemporaryChange<bool> reentrancyProtector(m_inPruneResources, true);

350

351 int size = m_allResources.size();

 
    if (targetSize && m_deadSize <= targetSize)

        return;

    bool canShrinkLRULists = true;

    for (int i = size - 1; i >= 0; i--) {

        // Remove from the tail, since this is the least frequently accessed of the objects.

        CachedResource* current = m_allResources[i].m_tail;

    for (int i = m_allResources.size() - 1; i >= 0; i--) {

        LRUList& list = *m_allResources[i];

361358 // First flush all the decoded data in this queue.

        while (current) {

            // Protect 'previous' so it can't get deleted during destroyDecodedData().

            CachedResourceHandle<CachedResource> previous = current->m_prevInAllResourcesList;

            ASSERT(!previous || previous->inCache());

            if (!current->hasClients() && !current->isPreloaded() && current->isLoaded()) {

        // Remove from the head, since this is the least frequently accessed of the objects.

        auto it = list.begin();

        while (it != list.end()) {

            CachedResource& current = **it;

            // Increment the iterator now as the call to destroyDecodedData() below may

            // invalidate the current iterator.

            ++it;

            // Protect 'next' so it can't get deleted during destroyDecodedData().

            CachedResourceHandle<CachedResource> next = it != list.end() ? *it : nullptr;

            ASSERT(!next || next->inCache());

            if (!current.hasClients() && !current.isPreloaded() && current.isLoaded()) {

                // Destroy our decoded data. This will remove us from 

                // m_liveDecodedResources, and possibly move us to a different 

                // LRU list in m_allResources.

370 current->destroyDecodedData();

375 current.destroyDecodedData();

                if (targetSize && m_deadSize <= targetSize)

                    return;

            }

375 // Decoded data may reference other resources. Stop iterating if 'pr~~evious~~' somehow got

380 // Decoded data may reference other resources. Stop iterating if 'next' somehow got

376381 // kicked out of cache during destroyDecodedData().

377 if (pr~~evious~~ && !pr~~evious~~->inCache())

382 if (next && !next->inCache())

378383 break;

379 current = previous.get();

380384 }

381385

        // Now evict objects from this queue.

        current = m_allResources[i].m_tail;

        while (current) {

            CachedResourceHandle<CachedResource> previous = current->m_prevInAllResourcesList;

            ASSERT(!previous || previous->inCache());

            if (!current->hasClients() && !current->isPreloaded() && !current->isCacheValidator()) {

                remove(*current);

        // Now evict objects from this list.

        // Remove from the head, since this is the least frequently accessed of the objects.

        it = list.begin();

        while (it != list.end()) {

            CachedResource& current = **it;

            // Increment the iterator now as the call to remove() below will

            // invalidate the current iterator.

            ++it;

            CachedResourceHandle<CachedResource> next = it != list.end() ? *it : nullptr;

            ASSERT(!next || next->inCache());

            if (!current.hasClients() && !current.isPreloaded() && !current.isCacheValidator()) {

                remove(current);

                if (targetSize && m_deadSize <= targetSize)

                    return;

            }

392 if (pr~~evious~~ && !pr~~evious~~->inCache())

403 if (next && !next->inCache())

393404 break;

394 current = previous.get();

        }

        // Shrink the vector back down so we don't waste time inspecting

        // empty LRU lists on future prunes.

399 if (m_allResources[i].~~m_head~~)

409 if (!m_allResources[i]->isEmpty())

400410 canShrinkLRULists = false;

401411 else if (canShrinkLRULists)

402 m_allResources.~~resize~~(i);

412 m_allResources.shrink(i);

    }

}

@@void MemoryCache::remove(CachedResource& resource)

    resource.deleteIfPossible();

}

448 ~~Mem~~oryCache::LRUList* MemoryCache::lruListFor(CachedResource& resource)

458auto MemoryCache::lruListFor(CachedResource& resource) -> LRUList&

{

    unsigned accessCount = std::max(resource.accessCount(), 1U);

    unsigned queueIndex = WTF::fastLog2(resource.size() / accessCount);

#ifndef NDEBUG

    resource.m_lruIndex = queueIndex;

#endif

    if (m_allResources.size() <= queueIndex)

        m_allResources.grow(queueIndex + 1);

    return &m_allResources[queueIndex];

    m_allResources.reserveCapacity(queueIndex + 1);

    while (m_allResources.size() <= queueIndex)

        m_allResources.uncheckedAppend(std::make_unique<LRUList>());

    return *m_allResources[queueIndex];

}

void MemoryCache::removeFromLRUList(CachedResource& resource)

@@void MemoryCache::removeFromLRUList(CachedResource& resource)

    unsigned oldListIndex = resource.m_lruIndex;

#endif

470 LRUList* list = lruListFor(resource);

482 LRUList& list = lruListFor(resource);

471483

472 #if !ASSERT_DISABLED

    // Verify that the list we got is the list we want.

    ASSERT(resource.m_lruIndex == oldListIndex);

    // Verify that we are in fact in this list.

    bool found = false;

    for (CachedResource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {

        if (current == &resource) {

            found = true;

            break;

        }

    }

    ASSERT(found);

#endif

    CachedResource* next = resource.m_nextInAllResourcesList;

    CachedResource* prev = resource.m_prevInAllResourcesList;

    if (!next && !prev && list->m_head != &resource)

        return;

    resource.m_nextInAllResourcesList = nullptr;

    resource.m_prevInAllResourcesList = nullptr;

    if (next)

        next->m_prevInAllResourcesList = prev;

    else if (list->m_tail == &resource)

        list->m_tail = prev;

    if (prev)

        prev->m_nextInAllResourcesList = next;

    else if (list->m_head == &resource)

        list->m_head = next;

487 bool removed = list.remove(&resource);

488 ASSERT_UNUSED(removed, removed);

}

void MemoryCache::insertInLRUList(CachedResource& resource)

{

509 // Make sure we aren't in some list already.

510 ASSERT(!resource.m_nextInAllResourcesList && !resource.m_prevInAllResourcesList);

    ASSERT(resource.inCache());

    ASSERT(resource.accessCount() > 0);

    LRUList* list = lruListFor(resource);

    resource.m_nextInAllResourcesList = list->m_head;

    if (list->m_head)

        list->m_head->m_prevInAllResourcesList = &resource;

    list->m_head = &resource;

    if (!resource.m_nextInAllResourcesList)

        list->m_tail = &resource;

#if !ASSERT_DISABLED

    // Verify that we are in now in the list like we should be.

    list = lruListFor(resource);

    bool found = false;

    for (CachedResource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {

        if (current == &resource) {

            found = true;

            break;

        }

    }

    ASSERT(found);

#endif

496 auto addResult = lruListFor(resource).add(&resource);

497 ASSERT_UNUSED(addResult, addResult.isNewEntry);

}

void MemoryCache::resourceAccessed(CachedResource& resource)

@@void MemoryCache::dumpLRULists(bool includeLive) const

    int size = m_allResources.size();

    for (int i = size - 1; i >= 0; i--) {

        printf("\n\nList %d: ", i);

        CachedResource* current = m_allResources[i].m_tail;

        while (current) {

            CachedResource* prev = current->m_prevInAllResourcesList;

            if (includeLive || !current->hasClients())

                printf("(%.1fK, %.1fK, %uA, %dR); ", current->decodedSize() / 1024.0f, (current->encodedSize() + current->overheadSize()) / 1024.0f, current->accessCount(), current->hasClients());

            current = prev;

        for (auto* resource : *m_allResources[i]) {

            if (includeLive || !resource->hasClients())

                printf("(%.1fK, %.1fK, %uA, %dR); ", resource->decodedSize() / 1024.0f, (resource->encodedSize() + resource->overheadSize()) / 1024.0f, resource->accessCount(), resource->hasClients());

Source/WebCore/loader/cache/MemoryCache.h

@@private:

#else

    typedef HashMap<URL, CachedResource*> CachedResourceMap;

#endif

    struct LRUList {

        CachedResource* m_head {nullptr};

        CachedResource* m_tail {nullptr};

    };

169 typedef ListHashSet<CachedResource*> LRUList;

    WEBCORE_EXPORT void pruneDeadResourcesToSize(unsigned targetSize);

    WEBCORE_EXPORT void pruneLiveResourcesToSize(unsigned targetSize, bool shouldDestroyDecodedDataForAllLiveResources = false);

@@private:

    MemoryCache();

    ~MemoryCache(); // Not implemented to make sure nobody accidentally calls delete -- WebCore does not delete singletons.

181 LRUList* lruListFor(CachedResource&);

177 LRUList& lruListFor(CachedResource&);

#ifndef NDEBUG

    void dumpStats();

    void dumpLRULists(bool includeLive) const;

@@private:

    // Size-adjusted and popularity-aware LRU list collection for cache objects.  This collection can hold

    // more resources than the cached resource map, since it can also hold "stale" multiple versions of objects that are

    // waiting to die when the clients referencing them go away.

209 Vector<LRUList, 32> m_allResources;

205 Vector<std::unique_ptr<LRUList>, 32> m_allResources;

210206

211207 // List just for live resources with decoded data. Access to this list is based off of painting the resource.

212 List~~HashSet<CachedResource*>~~ m_liveDecodedResources;

208 LRUList m_liveDecodedResources;

    
    // A URL-based map of all resources that are in the cache (including the freshest version of objects that are currently being 

    // referenced by a Web page).

Source/WebCore/ChangeLog

Source/WebCore/loader/cache/CachedResource.cpp

Source/WebCore/loader/cache/CachedResource.h

Source/WebCore/loader/cache/MemoryCache.cpp

Source/WebCore/loader/cache/MemoryCache.h