[Invalidation Tracking] Trace StyleInvalidator setNeedsStyleRecalc

Source/core/css/invalidation/DescendantInvalidationSet.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/css/invalidation/DescendantInvalidationSet.h"
 
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Element.h"
+#include "core/inspector/InspectorTraceEvents.h"
+#include "platform/TracedValue.h"
+#include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 DescendantInvalidationSet::DescendantInvalidationSet()
     : m_allDescendantsMightBeInvalid(false)
     , m_customPseudoInvalid(false)
     , m_treeBoundaryCrossing(false)
 {
 }
 
+template <StyleInvalidationTracingEnabledFlag styleInvalidationTracingEnabled>

[pdr., 2014/10/10 04:36:07]

This function is hot and we want it to be as fast as possible. At the same time,
we also need it to be as maintainable as possible for the first goal :) I think
we can do a little better in the second case.

Can we use the approach taken in GraphicsContextAnnotator? It sets a bit in
ContentLayerDelegate for whether the trace is enabled and hides the bit check
behind the ANNOTATE_GRAPHICS_CONTEXT macro.

[kouhei (in TOK), 2014/10/10 07:15:07]

I tried a similar approach but performance regression was still 4-5%. It looks
like any additional dynamic "if" stmts inside this function cause significant
regression.

 bool DescendantInvalidationSet::invalidatesElement(Element& element) const
 {
     if (m_allDescendantsMightBeInvalid)
         return true;
 
-    if (m_tagNames && m_tagNames->contains(element.tagQName().localName()))
+    if (m_tagNames && m_tagNames->contains(element.tagQName().localName())) {
+        if (styleInvalidationTracingEnabled == StyleInvalidationTracingEnabled)
+            TRACE_STYLE_INVALIDATOR_INVALIDATION_SELECTORPART(element, InvalidationSetMatchedTagName, element.tagQName().localName());
         return true;
+    }
 
-    if (element.hasID() && m_ids && m_ids->contains(element.idForStyleResolution()))
+    if (element.hasID() && m_ids && m_ids->contains(element.idForStyleResolution())) {
+        if (styleInvalidationTracingEnabled == StyleInvalidationTracingEnabled)
+            TRACE_STYLE_INVALIDATOR_INVALIDATION_SELECTORPART(element, InvalidationSetMatchedId, element.idForStyleResolution());
         return true;
+    }
 
     if (element.hasClass() && m_classes) {
         const SpaceSplitString& classNames = element.classNames();
         for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_classes->begin(); it != m_classes->end(); ++it) {
-            if (classNames.contains(*it))
+            if (classNames.contains(*it)) {
+                if (styleInvalidationTracingEnabled == StyleInvalidationTracingEnabled)
+                    TRACE_STYLE_INVALIDATOR_INVALIDATION_SELECTORPART(element, InvalidationSetMatchedClass, *it);
                 return true;
+            }
         }
     }
 
     if (element.hasAttributes() && m_attributes) {
         for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_attributes->begin(); it != m_attributes->end(); ++it) {
-            if (element.hasAttribute(*it))
+            if (element.hasAttribute(*it)) {
+                if (styleInvalidationTracingEnabled == StyleInvalidationTracingEnabled)
+                    TRACE_STYLE_INVALIDATOR_INVALIDATION_SELECTORPART(element, InvalidationSetMatchedAttribute, *it);
                 return true;
+            }
         }
     }
 
     return false;
 }
 
+template bool DescendantInvalidationSet::invalidatesElement<StyleInvalidationTracingEnabled>(Element&) const;
+template bool DescendantInvalidationSet::invalidatesElement<StyleInvalidationTracingDisabled>(Element&) const;
+
 void DescendantInvalidationSet::combine(const DescendantInvalidationSet& other)
 {
     // No longer bother combining data structures, since the whole subtree is deemed invalid.
     if (wholeSubtreeInvalid())
         return;
 
     if (other.wholeSubtreeInvalid()) {
         setWholeSubtreeInvalid();
         return;
     }
@@ skipping 101 matching lines @@
 void DescendantInvalidationSet::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_classes);
     visitor->trace(m_ids);
     visitor->trace(m_tagNames);
     visitor->trace(m_attributes);
 #endif
 }
 
+void DescendantInvalidationSet::toTracedValue(TracedValue* value) const
+{
+    value->beginDictionary();
+
+    if (m_allDescendantsMightBeInvalid)
+        value->setBoolean("allDescendantsMightBeInvalid", true);
+    if (m_customPseudoInvalid)
+        value->setBoolean("customPseudoInvalid", true);
+    if (m_treeBoundaryCrossing)
+        value->setBoolean("treeBoundaryCrossing", true);
+
+    if (m_ids) {
+        value->beginArray("ids");
+        for (const auto& id : *m_ids)
+            value->pushString(id);
+        value->endArray();
+    }
+
+    if (m_classes) {
+        value->beginArray("classes");
+        for (const auto& className : *m_classes)
+            value->pushString(className);
+        value->endArray();
+    }
+
+    if (m_tagNames) {
+        value->beginArray("tagNames");
+        for (const auto& tagName : *m_tagNames)
+            value->pushString(tagName);
+        value->endArray();
+    }
+
+    if (m_attributes) {
+        value->beginArray("ids");
+        for (const auto& attribute : *m_attributes)
+            value->pushString(attribute);
+        value->endArray();
+    }
+
+    value->endDictionary();
+}
+
 #ifndef NDEBUG
 void DescendantInvalidationSet::show() const
 {
-    fprintf(stderr, "DescendantInvalidationSet { ");
-    if (m_allDescendantsMightBeInvalid)
-        fprintf(stderr, "* ");
-    if (m_customPseudoInvalid)
-        fprintf(stderr, "::custom ");
-    if (m_treeBoundaryCrossing)
-        fprintf(stderr, "::shadow/deep/ ");
-    if (m_ids) {
-        for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_ids->begin(); it != m_ids->end(); ++it)
-            fprintf(stderr, "#%s ", (*it).ascii().data());
-    }
-    if (m_classes) {
-        for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_classes->begin(); it != m_classes->end(); ++it)
-            fprintf(stderr, ".%s ", (*it).ascii().data());
-    }
-    if (m_tagNames) {
-        for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_tagNames->begin(); it != m_tagNames->end(); ++it)
-            fprintf(stderr, "<%s> ", (*it).ascii().data());
-    }
-    if (m_attributes) {
-        for (WillBeHeapHashSet<AtomicString>::const_iterator it = m_attributes->begin(); it != m_attributes->end(); ++it)
-            fprintf(stderr, "[%s] ", (*it).ascii().data());
-    }
-    fprintf(stderr, "}\n");
+    RefPtr<TracedValue> value = TracedValue::create();
+    toTracedValue(value.get());
+    fprintf(stderr, "%s\n", value->asTraceFormat().ascii().data());
 }
 #endif // NDEBUG
 
 } // namespace blink