Changeset 34362 in webkit for trunk/JavaScriptCore/profiler/ProfileNode.cpp

Timestamp:

Jun 4, 2008, 11:53:10 AM (17 years ago)

Author:

[email protected]

Message:

2008-06-04 Kevin McCullough <​[email protected]>

Reviewed by Geoff.

<rdar://problem/5969992> JSProfiler: Remove the recursion limit in the
profiler.

• This patch removes the use of recursion for the sort functions.

• JavaScriptCore.exp: Change the signatures of the functions being exported.
• profiler/Profile.cpp: (KJS::Profile::sort): This generic function will accept any of the static sort functions and apply them to the whole tree.
• profiler/Profile.h: All of the sorting functions now call the new sort() function. (KJS::Profile::sortTotalTimeDescending): (KJS::Profile::sortTotalTimeAscending): (KJS::Profile::sortSelfTimeDescending): (KJS::Profile::sortSelfTimeAscending): (KJS::Profile::sortCallsDescending): (KJS::Profile::sortCallsAscending): (KJS::Profile::sortFunctionNameDescending): (KJS::Profile::sortFunctionNameAscending):
• profiler/ProfileNode.cpp: (KJS::ProfileNode::ProfileNode): m_head used to point to the head node if this was the head node. It now points to null to make iteration easy (KJS::ProfileNode::willExecute): Now must check if m_head is null, this check used to happend in the constructor. (KJS::ProfileNode::stopProfiling): Again the check is slightly different to determine if this is the head. (KJS::ProfileNode::traverseNextNode): This function returns the next node in post order. (KJS::ProfileNode::sort): This generic function will sort according to the comparator passed in, then reset the children pointers to macth the new order.
• profiler/ProfileNode.h: The sorting function were removed from the definition file and instead use the new generic sort() function (KJS::ProfileNode::totalPercent): because the head can now be empty we need to check here too for the head node. (KJS::ProfileNode::selfPercent): Ditto (KJS::ProfileNode::firstChild): This function is necessary for the iterative algorithm in Profile.cpp. (KJS::ProfileNode::sortTotalTimeDescending): (KJS::ProfileNode::sortTotalTimeAscending): (KJS::ProfileNode::sortSelfTimeDescending): (KJS::ProfileNode::sortSelfTimeAscending): (KJS::ProfileNode::sortCallsDescending): (KJS::ProfileNode::sortCallsAscending): (KJS::ProfileNode::sortFunctionNameDescending): (KJS::ProfileNode::sortFunctionNameAscending): (KJS::ProfileNode::childrenBegin): (KJS::ProfileNode::childrenEnd): (KJS::ProfileNode::totalTimeDescendingComparator): (KJS::ProfileNode::totalTimeAscendingComparator): (KJS::ProfileNode::selfTimeDescendingComparator): (KJS::ProfileNode::selfTimeAscendingComparator): (KJS::ProfileNode::callsDescendingComparator): (KJS::ProfileNode::callsAscendingComparator): (KJS::ProfileNode::functionNameDescendingComparator): (KJS::ProfileNode::functionNameAscendingComparator):

File:

• trunk/JavaScriptCore/profiler/ProfileNode.cpp (modified) (4 diffs)

trunk/JavaScriptCore/profiler/ProfileNode.cpp

@@ -70 +70 @@
     , m_visible(true)
 {
-    if (!m_head)
-        m_head = this;
-
     startTimer();
 }
@@ -85 +82 @@
     }
 
-    RefPtr<ProfileNode> newChild = ProfileNode::create(callIdentifier, m_head, this);
+    RefPtr<ProfileNode> newChild = ProfileNode::create(callIdentifier, m_head ? m_head : this, this);   // If this ProfileNode has no head it is the head.
     if (m_children.size())
         m_children.last()->setNextSibling(newChild.get());
@@ -137 +134 @@
     m_actualSelfTime = m_actualTotalTime - m_actualSelfTime;
 
-    if (m_head == this && m_actualSelfTime) {
+    if (!m_head && m_actualSelfTime) {
         ProfileNode* idleNode = willExecute(CallIdentifier(NonJSExecution, 0, 0));
 
@@ -150 +147 @@
 }
 
-// Sorting methods
-
-static inline bool totalTimeDescendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->totalTime() > b->totalTime();
-}
-
-void ProfileNode::sortTotalTimeDescending()
-{
-    std::sort(m_children.begin(), m_children.end(), totalTimeDescendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortTotalTimeDescending();
-    
-    resetChildrensSiblings();
-}
-
-static inline bool totalTimeAscendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->totalTime() < b->totalTime();
-}
-
-void ProfileNode::sortTotalTimeAscending()
-{
-    std::sort(m_children.begin(), m_children.end(), totalTimeAscendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortTotalTimeAscending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool selfTimeDescendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->selfTime() > b->selfTime();
-}
-
-void ProfileNode::sortSelfTimeDescending()
-{
-    std::sort(m_children.begin(), m_children.end(), selfTimeDescendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortSelfTimeDescending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool selfTimeAscendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->selfTime() < b->selfTime();
-}
-
-void ProfileNode::sortSelfTimeAscending()
-{
-    std::sort(m_children.begin(), m_children.end(), selfTimeAscendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortSelfTimeAscending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool callsDescendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->numberOfCalls() > b->numberOfCalls();
-}
-
-void ProfileNode::sortCallsDescending()
-{
-    std::sort(m_children.begin(), m_children.end(), callsDescendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortCallsDescending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool callsAscendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->numberOfCalls() < b->numberOfCalls();
-}
-
-void ProfileNode::sortCallsAscending()
-{
-    std::sort(m_children.begin(), m_children.end(), callsAscendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortCallsAscending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool functionNameDescendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->functionName() > b->functionName();
-}
-
-void ProfileNode::sortFunctionNameDescending()
-{
-    std::sort(m_children.begin(), m_children.end(), functionNameDescendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortFunctionNameDescending();
-
-    resetChildrensSiblings();
-}
-
-static inline bool functionNameAscendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b)
-{
-    return a->functionName() < b->functionName();
-}
-
-void ProfileNode::sortFunctionNameAscending()
-{
-    std::sort(m_children.begin(), m_children.end(), functionNameAscendingComparator);
-
-    unsigned size = m_children.size();
-    for (unsigned i = 0; i < size; ++i)
-        m_children[i]->sortFunctionNameAscending();
-
+ProfileNode* ProfileNode::traverseNextNode() const
+{
+    ProfileNode* next = m_nextSibling;
+    if (!next)
+        return m_parent;
+    while (ProfileNode* firstChild = next->firstChild())
+        next = firstChild;
+    return next;
+}
+
+void ProfileNode::sort(bool comparator(const RefPtr<ProfileNode>& , const RefPtr<ProfileNode>& ))
+{
+    std::sort(childrenBegin(), childrenEnd(), comparator);    
     resetChildrensSiblings();
 }