blob: 5b6a25411deb6b5838d60d65b1a2414cd855d110 [file] [log] [blame]
/*
* Copyright (C) 2008 Apple 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:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY 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 "ProfileNode.h"
#include "LegacyProfiler.h"
#include <stdio.h>
#include <wtf/DateMath.h>
#include <wtf/DataLog.h>
#include <wtf/text/StringHash.h>
#if OS(WINDOWS)
#include <windows.h>
#endif
using namespace WTF;
namespace JSC {
static double getCount()
{
#if OS(WINDOWS)
static LARGE_INTEGER frequency;
if (!frequency.QuadPart)
QueryPerformanceFrequency(&frequency);
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
return static_cast<double>(counter.QuadPart) / frequency.QuadPart;
#else
return currentTimeMS();
#endif
}
ProfileNode::ProfileNode(ExecState* callerCallFrame, const CallIdentifier& callIdentifier, ProfileNode* headNode, ProfileNode* parentNode)
: m_callerCallFrame(callerCallFrame)
, m_callIdentifier(callIdentifier)
, m_head(headNode)
, m_parent(parentNode)
, m_nextSibling(0)
, m_startTime(0.0)
, m_actualTotalTime(0.0)
, m_visibleTotalTime(0.0)
, m_actualSelfTime(0.0)
, m_visibleSelfTime(0.0)
, m_numberOfCalls(0)
, m_visible(true)
{
startTimer();
}
ProfileNode::ProfileNode(ExecState* callerCallFrame, ProfileNode* headNode, ProfileNode* nodeToCopy)
: m_callerCallFrame(callerCallFrame)
, m_callIdentifier(nodeToCopy->callIdentifier())
, m_head(headNode)
, m_parent(nodeToCopy->parent())
, m_nextSibling(0)
, m_startTime(0.0)
, m_actualTotalTime(nodeToCopy->actualTotalTime())
, m_visibleTotalTime(nodeToCopy->totalTime())
, m_actualSelfTime(nodeToCopy->actualSelfTime())
, m_visibleSelfTime(nodeToCopy->selfTime())
, m_numberOfCalls(nodeToCopy->numberOfCalls())
, m_visible(nodeToCopy->visible())
{
}
ProfileNode* ProfileNode::willExecute(ExecState* callerCallFrame, const CallIdentifier& callIdentifier)
{
for (StackIterator currentChild = m_children.begin(); currentChild != m_children.end(); ++currentChild) {
if ((*currentChild)->callIdentifier() == callIdentifier) {
(*currentChild)->startTimer();
return (*currentChild).get();
}
}
RefPtr<ProfileNode> newChild = ProfileNode::create(callerCallFrame, 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());
m_children.append(newChild.release());
return m_children.last().get();
}
ProfileNode* ProfileNode::didExecute()
{
endAndRecordCall();
return m_parent;
}
void ProfileNode::addChild(PassRefPtr<ProfileNode> prpChild)
{
RefPtr<ProfileNode> child = prpChild;
child->setParent(this);
if (m_children.size())
m_children.last()->setNextSibling(child.get());
m_children.append(child.release());
}
ProfileNode* ProfileNode::findChild(ProfileNode* node) const
{
if (!node)
return 0;
for (size_t i = 0; i < m_children.size(); ++i) {
if (*node == m_children[i].get())
return m_children[i].get();
}
return 0;
}
void ProfileNode::removeChild(ProfileNode* node)
{
if (!node)
return;
for (size_t i = 0; i < m_children.size(); ++i) {
if (*node == m_children[i].get()) {
m_children.remove(i);
break;
}
}
resetChildrensSiblings();
}
void ProfileNode::insertNode(PassRefPtr<ProfileNode> prpNode)
{
RefPtr<ProfileNode> node = prpNode;
for (unsigned i = 0; i < m_children.size(); ++i)
node->addChild(m_children[i].release());
m_children.clear();
m_children.append(node.release());
}
void ProfileNode::stopProfiling()
{
if (m_startTime)
endAndRecordCall();
m_visibleTotalTime = m_actualTotalTime;
ASSERT(m_actualSelfTime == 0.0 && m_startTime == 0.0);
// Because we iterate in post order all of our children have been stopped before us.
for (unsigned i = 0; i < m_children.size(); ++i)
m_actualSelfTime += m_children[i]->totalTime();
ASSERT(m_actualSelfTime <= m_actualTotalTime);
m_actualSelfTime = m_actualTotalTime - m_actualSelfTime;
m_visibleSelfTime = m_actualSelfTime;
}
ProfileNode* ProfileNode::traverseNextNodePostOrder() const
{
ProfileNode* next = m_nextSibling;
if (!next)
return m_parent;
while (ProfileNode* firstChild = next->firstChild())
next = firstChild;
return next;
}
ProfileNode* ProfileNode::traverseNextNodePreOrder(bool processChildren) const
{
if (processChildren && m_children.size())
return m_children[0].get();
if (m_nextSibling)
return m_nextSibling;
ProfileNode* nextParent = m_parent;
if (!nextParent)
return 0;
ProfileNode* next;
for (next = m_parent->nextSibling(); !next; next = nextParent->nextSibling()) {
nextParent = nextParent->parent();
if (!nextParent)
return 0;
}
return next;
}
void ProfileNode::setTreeVisible(ProfileNode* node, bool visible)
{
ProfileNode* nodeParent = node->parent();
ProfileNode* nodeSibling = node->nextSibling();
node->setParent(0);
node->setNextSibling(0);
for (ProfileNode* currentNode = node; currentNode; currentNode = currentNode->traverseNextNodePreOrder())
currentNode->setVisible(visible);
node->setParent(nodeParent);
node->setNextSibling(nodeSibling);
}
void ProfileNode::calculateVisibleTotalTime()
{
double sumOfVisibleChildrensTime = 0.0;
for (unsigned i = 0; i < m_children.size(); ++i) {
if (m_children[i]->visible())
sumOfVisibleChildrensTime += m_children[i]->totalTime();
}
m_visibleTotalTime = m_visibleSelfTime + sumOfVisibleChildrensTime;
}
bool ProfileNode::focus(const CallIdentifier& callIdentifier)
{
if (!m_visible)
return false;
if (m_callIdentifier != callIdentifier) {
m_visible = false;
return true;
}
for (ProfileNode* currentParent = m_parent; currentParent; currentParent = currentParent->parent())
currentParent->setVisible(true);
return false;
}
void ProfileNode::exclude(const CallIdentifier& callIdentifier)
{
if (m_visible && m_callIdentifier == callIdentifier) {
setTreeVisible(this, false);
m_parent->setVisibleSelfTime(m_parent->selfTime() + m_visibleTotalTime);
}
}
void ProfileNode::restore()
{
m_visibleTotalTime = m_actualTotalTime;
m_visibleSelfTime = m_actualSelfTime;
m_visible = true;
}
void ProfileNode::endAndRecordCall()
{
m_actualTotalTime += m_startTime ? getCount() - m_startTime : 0.0;
m_startTime = 0.0;
++m_numberOfCalls;
}
void ProfileNode::startTimer()
{
if (!m_startTime)
m_startTime = getCount();
}
void ProfileNode::resetChildrensSiblings()
{
unsigned size = m_children.size();
for (unsigned i = 0; i < size; ++i)
m_children[i]->setNextSibling(i + 1 == size ? 0 : m_children[i + 1].get());
}
#ifndef NDEBUG
void ProfileNode::debugPrintData(int indentLevel) const
{
// Print function names
for (int i = 0; i < indentLevel; ++i)
dataLogF(" ");
dataLogF("Function Name %s %d SelfTime %.3fms/%.3f%% TotalTime %.3fms/%.3f%% VSelf %.3fms VTotal %.3fms Visible %s Next Sibling %s\n",
functionName().utf8().data(),
m_numberOfCalls, m_actualSelfTime, selfPercent(), m_actualTotalTime, totalPercent(),
m_visibleSelfTime, m_visibleTotalTime,
(m_visible ? "True" : "False"),
m_nextSibling ? m_nextSibling->functionName().utf8().data() : "");
++indentLevel;
// Print children's names and information
for (StackIterator currentChild = m_children.begin(); currentChild != m_children.end(); ++currentChild)
(*currentChild)->debugPrintData(indentLevel);
}
// print the profiled data in a format that matches the tool sample's output.
double ProfileNode::debugPrintDataSampleStyle(int indentLevel, FunctionCallHashCount& countedFunctions) const
{
dataLogF(" ");
// Print function names
const char* name = functionName().utf8().data();
double sampleCount = m_actualTotalTime * 1000;
if (indentLevel) {
for (int i = 0; i < indentLevel; ++i)
dataLogF(" ");
countedFunctions.add(functionName().impl());
dataLogF("%.0f %s\n", sampleCount ? sampleCount : 1, name);
} else
dataLogF("%s\n", name);
++indentLevel;
// Print children's names and information
double sumOfChildrensCount = 0.0;
for (StackIterator currentChild = m_children.begin(); currentChild != m_children.end(); ++currentChild)
sumOfChildrensCount += (*currentChild)->debugPrintDataSampleStyle(indentLevel, countedFunctions);
sumOfChildrensCount *= 1000; //
// Print remainder of samples to match sample's output
if (sumOfChildrensCount < sampleCount) {
dataLogF(" ");
while (indentLevel--)
dataLogF(" ");
dataLogF("%.0f %s\n", sampleCount - sumOfChildrensCount, functionName().utf8().data());
}
return m_actualTotalTime;
}
#endif
} // namespace JSC