ChangeLog

2012-03-09  Antti Koivisto  <antti@apple.com>

        Presentation attribute cache

        https://bugs.webkit.org/show_bug.cgi?id=80707

        It is common for the same presentation attribute values repeat. We should introduce a cache that uses 

        presentation attribute names and values as key. This will help to avoid repeated parsing of the 

        same attribute values, reduce memory consumption and speed up the style resolve.

        This patch introduces a simple and small (128 entries) global cache. In general web browsing it seems

        to give sharing rate of >75% (an average presentation attribute property set is shared between >4 elements).

        * dom/StyledElement.cpp:

        (WebCore::PresentationAttributeCacheKey::PresentationAttributeCacheKey):

        (PresentationAttributeCacheKey):

        (WebCore):

        (WebCore::operator!=):

        (PresentationAttributeCacheEntry):

        (WebCore::presentationAttributeCache):

        (WebCore::attributeNameSort):

        (WebCore::StyledElement::makePresentationAttributeCacheKey):

        (WebCore::computePresentationAttributeCacheHash):

        (WebCore::StyledElement::updateAttributeStyle):

        * dom/StyledElement.h:

        (WebCore):

        (StyledElement):

2012-03-09  Nate Chapin  <japhet@chromium.org>

        CachedRawResource breaks when trying to load

110303

Source/WebCore/dom/StyledElement.cpp

@@namespace WebCore {

using namespace HTMLNames;

struct PresentationAttributeCacheKey {

    PresentationAttributeCacheKey() : tagName(0) { }

    AtomicStringImpl* tagName;

    // Only the values need refcounting.

    Vector<pair<AtomicStringImpl*, AtomicString>, 3> attributesAndValues;

};

struct PresentationAttributeCacheEntry {

    PresentationAttributeCacheKey key;

    RefPtr<StylePropertySet> value;

};

typedef HashMap<unsigned, OwnPtr<PresentationAttributeCacheEntry>, AlreadyHashed> PresentationAttributeCache;

static bool operator!=(const PresentationAttributeCacheKey& a, const PresentationAttributeCacheKey& b)

{

    if (a.tagName != b.tagName)

        return true;

    return a.attributesAndValues != b.attributesAndValues;

}

static PresentationAttributeCache& presentationAttributeCache()

{

    static PresentationAttributeCache* cache = new PresentationAttributeCache();

    return *cache;

}

void StyledElement::updateStyleAttribute() const

{

    ASSERT(!isStyleAttributeValid());

@@void StyledElement::addSubresourceAttrib

        inlineStyle->addSubresourceStyleURLs(urls, document()->elementSheet());

}

160 ~~void StyledElement::upd~~ateAttribute~~Style(~~)

187static inline bool attributeNameSort(const pair<AtomicStringImpl*, AtomicString>& p1, const pair<AtomicStringImpl*, AtomicString>& p2)

161188{

162 RefPtr<StylePropertySet> style = StylePropertySet::create();

163 for (unsigned i = 0; i < attributeCount(); ++i) {

    // Sort based on the attribute name pointers. It doesn't matter what the order is as long as it is always the same. 

    return p1.first < p2.first;

}

void StyledElement::makePresentationAttributeCacheKey(PresentationAttributeCacheKey& result) const

{    

    // FIXME: Enable for SVG.

    if (namespaceURI() != xhtmlNamespaceURI)

        return;

    unsigned size = attributeCount();

    for (unsigned i = 0; i < size; ++i) {

164200 Attribute* attribute = attributeItem(i);

165 collectStyleForAttribute(attribute, style.get());

        if (!isPresentationAttribute(attribute->name()))

            continue;

        if (!attribute->namespaceURI().isNull())

            return;

        // FIXME: Background URL may depend on the base URL and can't be shared. Disallow caching.

        if (attribute->name() == backgroundAttr)

            return;

        result.attributesAndValues.append(make_pair(attribute->localName().impl(), attribute->value()));

    }

    if (result.attributesAndValues.isEmpty())

        return;

    // Attribute order doesn't matter. Sort for easy equality comparison.

    std::sort(result.attributesAndValues.begin(), result.attributesAndValues.end(), attributeNameSort);

    // The cache key is non-null when the tagName is set.

    result.tagName = localName().impl();

}

static unsigned computePresentationAttributeCacheHash(const PresentationAttributeCacheKey& key)

{

    if (!key.tagName)

        return 0;

    ASSERT(key.attributesAndValues.size());

    unsigned attributeHash = StringHasher::hashMemory(key.attributesAndValues.data(), key.attributesAndValues.size() * sizeof(key.attributesAndValues[0]));

    return WTF::intHash((static_cast<uint64_t>(key.tagName->existingHash()) << 32 | attributeHash));

}

void StyledElement::updateAttributeStyle()

{

    PresentationAttributeCacheKey cacheKey;

    makePresentationAttributeCacheKey(cacheKey);

    unsigned cacheHash = computePresentationAttributeCacheHash(cacheKey);

    PresentationAttributeCache::iterator cacheIterator;

    if (cacheHash) {

        cacheIterator = presentationAttributeCache().add(cacheHash, nullptr).first;

        if (cacheIterator->second && cacheIterator->second->key != cacheKey)

            cacheHash = 0;

    }

    RefPtr<StylePropertySet> style;

    if (cacheHash && cacheIterator->second) 

        style = cacheIterator->second->value;

    else {

        style = StylePropertySet::create();

        unsigned size = attributeCount();

        for (unsigned i = 0; i < size; ++i) {

            Attribute* attribute = attributeItem(i);

            collectStyleForAttribute(attribute, style.get());

        }

    }

    clearAttributeStyleDirty();

@@void StyledElement::updateAttributeStyle

        attributeData()->setAttributeStyle(0);

    else {

        style->shrinkToFit();

173 attributeData()->setAttributeStyle(style~~.release()~~);

258 attributeData()->setAttributeStyle(style);

174259 }

    if (!cacheHash || cacheIterator->second)

        return;

    OwnPtr<PresentationAttributeCacheEntry> newEntry = adoptPtr(new PresentationAttributeCacheEntry);

    newEntry->key = cacheKey;

    newEntry->value = style.release();

    static const int presentationAttributeCacheMaximumSize = 128;

    if (presentationAttributeCache().size() > presentationAttributeCacheMaximumSize) {

        // Start building from scratch if the cache ever gets big.

        presentationAttributeCache().clear();

        presentationAttributeCache().set(cacheHash, newEntry.release());

    } else

        cacheIterator->second = newEntry.release();

}

void StyledElement::addPropertyToAttributeStyle(StylePropertySet* style, int propertyID, int identifier)

110298

Source/WebCore/ChangeLog

Source/WebCore/dom/StyledElement.cpp

Source/WebCore/dom/StyledElement.h