Changeset 116402 in webkit

Timestamp:

May 8, 2012 1:31:29 AM (12 years ago)

Author:

Antti Koivisto

Message:

Inline Node::traverseNextNode
​https://bugs.webkit.org/show_bug.cgi?id=85844

Reviewed by Ryosuke Niwa.

Inline traverseNextNode and traverseNextSibling to reduce entry/exit overhead and allow better code generation
for many hot loops. Also added separate versions of stayWithin and unscoped cases (the function is
so simple that this seemed like the cleanest way to do it, the most reliable too) and used UNLIKELY for the
end-of-traversal conditions.

The traversal function can show up to ~1% in normal page loading profiles.

run-perf-tests seems to think this is a progression in some subtests though bots will tell for certain.

• WebCore.exp.in:
• dom/ContainerNode.h:

Following the existing pattern, function bodies go to ContainerNode.h so they can call parentNode().
(which returns ContainerNode, not Node).

(WebCore::Node::traverseNextNode):
(WebCore):
(WebCore::Node::traverseNextSibling):

• dom/Node.cpp:

(WebCore):

• dom/Node.h:

(Node):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.exp.in (modified) (1 diff)
• bindings/v8/RetainedDOMInfo.cpp (modified) (1 diff)
• dom/ContainerNode.h (modified) (1 diff)
• dom/Node.cpp (modified) (1 diff)
• dom/Node.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-05-07  Antti Koivisto  <antti@apple.com>
+
+        Inline Node::traverseNextNode
+        https://bugs.webkit.org/show_bug.cgi?id=85844
+
+        Reviewed by Ryosuke Niwa.
+
+        Inline traverseNextNode and traverseNextSibling to reduce entry/exit overhead and allow better code generation
+        for many hot loops. Also added separate versions of stayWithin and unscoped cases (the function is
+        so simple that this seemed like the cleanest way to do it, the most reliable too) and used UNLIKELY for the 
+        end-of-traversal conditions.
+        
+        The traversal function can show up to ~1% in normal page loading profiles.
+        
+        run-perf-tests seems to think this is a progression in some subtests though bots will tell for certain.
+
+        * WebCore.exp.in:
+        * dom/ContainerNode.h:
+        
+            Following the existing pattern, function bodies go to ContainerNode.h so they can call parentNode().
+            (which returns ContainerNode, not Node).
+
+        (WebCore::Node::traverseNextNode):
+        (WebCore):
+        (WebCore::Node::traverseNextSibling):
+        * dom/Node.cpp:
+        (WebCore):
+        * dom/Node.h:
+        (Node):
+
 2012-05-05  Pavel Feldman  <pfeldman@chromium.org>
 

trunk/Source/WebCore/WebCore.exp.in

@@ -2097 +2097 @@
 __ZN7WebCore8Document22setAnimatingFullScreenEb
 __ZNK7WebCore8Document9domWindowEv
-__ZNK7WebCore4Node16traverseNextNodeEPKS0_
 #endif
 

trunk/Source/WebCore/bindings/v8/RetainedDOMInfo.cpp

@@ -32 +32 @@
 #include "RetainedDOMInfo.h"
 
-#include "Node.h"
+#include "ContainerNode.h"
 
 namespace WebCore {

trunk/Source/WebCore/dom/ContainerNode.h

@@ -229 +229 @@
 }
 
+inline Node* Node::traverseNextNode() const
+{
+    if (firstChild())
+        return firstChild();
+    if (nextSibling())
+        return nextSibling();
+    const Node* node = this;
+    while (node && !node->nextSibling())
+        node = node->parentNode();
+    if (UNLIKELY(!node))
+        return 0;
+    return node->nextSibling();
+}
+
+inline Node* Node::traverseNextNode(const Node* stayWithin) const
+{
+    if (firstChild())
+        return firstChild();
+    if (UNLIKELY(this == stayWithin))
+        return 0;
+    if (nextSibling())
+        return nextSibling();
+    const Node* node = this;
+    while (node && !node->nextSibling() && (!stayWithin || node->parentNode() != stayWithin))
+        node = node->parentNode();
+    if (UNLIKELY(!node))
+        return 0;
+    return node->nextSibling();
+}
+
+inline Node* Node::traverseNextSibling() const
+{
+    if (nextSibling())
+        return nextSibling();
+    const Node* node = this;
+    while (node && !node->nextSibling())
+        node = node->parentNode();
+    if (UNLIKELY(!node))
+        return 0;
+    return node->nextSibling();
+}
+
+inline Node* Node::traverseNextSibling(const Node* stayWithin) const
+{
+    if (UNLIKELY(this == stayWithin))
+        return 0;
+    if (nextSibling())
+        return nextSibling();
+    const Node* node = this;
+    while (node && !node->nextSibling() && (!stayWithin || node->parentNode() != stayWithin))
+        node = node->parentNode();
+    if (UNLIKELY(!node))
+        return 0;
+    return node->nextSibling();
+}
+
 typedef Vector<RefPtr<Node>, 11> NodeVector;
 

trunk/Source/WebCore/dom/Node.cpp

@@ -1085 +1085 @@
 }
 
-Node* Node::traverseNextNode(const Node* stayWithin) const
-{
-    if (firstChild())
-        return firstChild();
-    if (this == stayWithin)
-        return 0;
-    if (nextSibling())
-        return nextSibling();
-    const Node *n = this;
-    while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
-        n = n->parentNode();
-    if (n)
-        return n->nextSibling();
-    return 0;
-}
-
-Node* Node::traverseNextSibling(const Node* stayWithin) const
-{
-    if (this == stayWithin)
-        return 0;
-    if (nextSibling())
-        return nextSibling();
-    const Node *n = this;
-    while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
-        n = n->parentNode();
-    if (n)
-        return n->nextSibling();
-    return 0;
-}
-
 Node* Node::traverseNextNodePostOrder() const
 {

trunk/Source/WebCore/dom/Node.h

@@ -428 +428 @@
     // argument is non-null, the traversal will stop once the specified node is reached.
     // This can be used to restrict traversal to a particular sub-tree.
-    Node* traverseNextNode(const Node* stayWithin = 0) const;
+    Node* traverseNextNode() const;
+    Node* traverseNextNode(const Node* stayWithin) const;
 
     // Like traverseNextNode, but skips children and starts with the next sibling.
-    Node* traverseNextSibling(const Node* stayWithin = 0) const;
+    Node* traverseNextSibling() const;
+    Node* traverseNextSibling(const Node* stayWithin) const;
 
     // Does a reverse pre-order traversal to find the node that comes before the current one in document order