Changeset 72160 in webkit for trunk/JavaScriptCore/profiler/ProfileNode.h

Timestamp:

Nov 16, 2010, 7:03:34 PM (15 years ago)

Author:

[email protected]

Message:

Bug 49635 - Profiler implementation is fragile

Reviewed by Sam Weinig.

The profile presently requires the exception handling mechanism to explicitly
remove all stack frames that are exited during the exception unwind mechanism.
This is fragile in a number of ways:

• We have to change bytecode register allocation when compiling code to run when profiling, to preserve the callee function (this is also required to call did_call after the call has returned).
• In the JIT we have to maintain additional data structures (CodeBlock::RareData::m_functionRegisterInfos) to map back to the register containing the callee.
• In the interpreter we use 'magic values' to offset into the instruction stream to rediscover the register containing the function.

Instead, move profiling into the head and tail of functions.

• This correctly accounts the cost of the call itself to the caller.
• This allows us to access the callee function object from the callframe.
• This means that at the point a call is made we can track the stack depth on the ProfileNode.
• When unwinding we can simply report the depth at which the exception is being handled - all call frames above this level are freed.

• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dump):
(JSC::CodeBlock::shrinkToFit):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::bytecodeOffset):
(JSC::CodeBlock::methodCallLinkInfo):

• bytecode/Opcode.h:
• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitCall):
(JSC::BytecodeGenerator::emitCallVarargs):
(JSC::BytecodeGenerator::emitReturn):
(JSC::BytecodeGenerator::emitConstruct):

• bytecompiler/BytecodeGenerator.h:

(JSC::CallArguments::count):

• bytecompiler/NodesCodegen.cpp:

(JSC::CallArguments::CallArguments):

• interpreter/Interpreter.cpp:

(JSC::ProfileHostCall::ProfileHostCall):
(JSC::ProfileHostCall::~ProfileHostCall):
(JSC::Interpreter::unwindCallFrame):
(JSC::Interpreter::throwException):
(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::privateExecute):

• jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass):

• jit/JIT.h:
• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_profile_has_called):
(JSC::JIT::emit_op_profile_will_return):

• jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_profile_has_called):
(JSC::JIT::emit_op_profile_will_return):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• jit/JITStubs.h:
• profiler/Profile.cpp:

(JSC::Profile::Profile):

• profiler/ProfileGenerator.cpp:

(JSC::ProfileGenerator::addParentForConsoleStart):
(JSC::ProfileGenerator::willExecute):
(JSC::ProfileGenerator::didExecute):
(JSC::ProfileGenerator::exceptionUnwind):
(JSC::ProfileGenerator::stopProfiling):

• profiler/ProfileGenerator.h:
• profiler/ProfileNode.cpp:

(JSC::ProfileNode::ProfileNode):
(JSC::ProfileNode::willExecute):

• profiler/ProfileNode.h:

(JSC::ProfileNode::create):
(JSC::ProfileNode::operator==):
(JSC::ProfileNode::exec):

• profiler/Profiler.cpp:

(JSC::dispatchFunctionToProfiles):
(JSC::Profiler::hasCalled):
(JSC::Profiler::willEvaluate):
(JSC::Profiler::willReturn):
(JSC::Profiler::didEvaluate):
(JSC::Profiler::exceptionUnwind):

• profiler/Profiler.h:

File:

• trunk/JavaScriptCore/profiler/ProfileNode.h (modified) (5 diffs)

trunk/JavaScriptCore/profiler/ProfileNode.h

@@ -38 +38 @@
 namespace JSC {
 
+    class ExecState;
     class ProfileNode;
 
@@ -45 +46 @@
     class ProfileNode : public RefCounted<ProfileNode> {
     public:
-        static PassRefPtr<ProfileNode> create(const CallIdentifier& callIdentifier, ProfileNode* headNode, ProfileNode* parentNode)
+        static PassRefPtr<ProfileNode> create(ExecState* exec, const CallIdentifier& callIdentifier, ProfileNode* headNode, ProfileNode* parentNode)
         {
-            return adoptRef(new ProfileNode(callIdentifier, headNode, parentNode));
+            return adoptRef(new ProfileNode(exec, callIdentifier, headNode, parentNode));
         }
-        static PassRefPtr<ProfileNode> create(ProfileNode* headNode, ProfileNode* node)
+        static PassRefPtr<ProfileNode> create(ExecState* exec, ProfileNode* headNode, ProfileNode* node)
         {
-            return adoptRef(new ProfileNode(headNode, node));
+            return adoptRef(new ProfileNode(exec, headNode, node));
         }
 
-        bool operator==(ProfileNode* node) { return m_callIdentifier == node->callIdentifier(); }
+        bool operator==(ProfileNode* node) { return m_exec == node->m_exec && m_callIdentifier == node->callIdentifier(); }
 
-        ProfileNode* willExecute(const CallIdentifier&);
+        ProfileNode* willExecute(ExecState* exec, const CallIdentifier&);
         ProfileNode* didExecute();
 
@@ -62 +63 @@
 
         // CallIdentifier members
+        const ExecState* exec() const { return m_exec; }
         const CallIdentifier& callIdentifier() const { return m_callIdentifier; }
         const UString& functionName() const { return m_callIdentifier.m_name; }
@@ -129 +131 @@
 
     private:
-        ProfileNode(const CallIdentifier&, ProfileNode* headNode, ProfileNode* parentNode);
-        ProfileNode(ProfileNode* headNode, ProfileNode* nodeToCopy);
+        ProfileNode(ExecState* exec, const CallIdentifier&, ProfileNode* headNode, ProfileNode* parentNode);
+        ProfileNode(ExecState* exec, ProfileNode* headNode, ProfileNode* nodeToCopy);
 
         void startTimer();
@@ -148 +150 @@
         static inline bool functionNameAscendingComparator(const RefPtr<ProfileNode>& a, const RefPtr<ProfileNode>& b) { return a->functionName() < b->functionName(); }
 
+        ExecState* m_exec;
         CallIdentifier m_callIdentifier;
         ProfileNode* m_head;