Changeset 43047 in webkit for trunk/JavaScriptCore/bytecode/SamplingTool.cpp

Timestamp:

Apr 30, 2009, 12:52:27 AM (16 years ago)

Author:

[email protected]

Message:

2009-04-30 Gavin Barraclough <​[email protected]>

Reviewed by Maciej Stachowiak.

Add SamplingFlags mechanism.

This mechanism allows fine-grained JSC and JavaScript program aware
performance measurement. The mechanism provides a set of 32 flags,
numbered #1..#32. Flag #16 is initially set, and all other flags
are cleared. Flags may be set and cleared from within

Enable by setting ENABLE_SAMPLING_FLAGS to 1 in wtf/Platform.h.
Disabled by default, no performance impact. Flags may be modified
by calling SamplingFlags::setFlag() and SamplingFlags::clearFlag()
from within JSC implementation, or by calling setSamplingFlag() and
clearSamplingFlag() from JavaScript.

The flags are sampled with a frequency of 10000Hz, and the highest
set flag in recorded, allowing multiple events to be measured (with
the highest flag number representing the highest priority).

Disabled by default; no performance impact.

• JavaScriptCore.exp:
• bytecode/SamplingTool.cpp: (JSC::SamplingFlags::sample): (JSC::SamplingFlags::start): (JSC::SamplingFlags::stop): (JSC::SamplingThread::threadStartFunc): (JSC::SamplingThread::start): (JSC::SamplingThread::stop): (JSC::ScopeSampleRecord::sample): (JSC::SamplingTool::doRun): (JSC::SamplingTool::sample): (JSC::SamplingTool::start): (JSC::SamplingTool::stop):
• bytecode/SamplingTool.h: (JSC::SamplingFlags::setFlag): (JSC::SamplingFlags::clearFlag): (JSC::SamplingTool::SamplingTool):
• jsc.cpp: (GlobalObject::GlobalObject): (functionSetSamplingFlag): (functionClearSamplingFlag): (runWithScripts):
• wtf/Platform.h:

File:

• trunk/JavaScriptCore/bytecode/SamplingTool.cpp (modified) (3 diffs)

trunk/JavaScriptCore/bytecode/SamplingTool.cpp

@@ -40 +40 @@
 namespace JSC {
 
+#if ENABLE(SAMPLING_FLAGS)
+
+void SamplingFlags::sample()
+{
+    uint32_t mask = 1 << 31;
+    unsigned index;
+
+    for (index = 0; index < 32; ++index) {
+        if (mask & s_flags)
+            break;
+        mask >>= 1;
+    }
+
+    s_flagCounts[32 - index]++;
+}
+
+void SamplingFlags::start()
+{
+    for (unsigned i = 0; i <= 32; ++i)
+        s_flagCounts[i] = 0;
+}
+void SamplingFlags::stop()
+{
+    uint64_t total = 0;
+    for (unsigned i = 0; i <= 32; ++i)
+        total += s_flagCounts[i];
+
+    printf("SamplingFlags: sample count with flags set:\n");
+    for (unsigned i = 0; i <= 32; ++i)
+        printf("  [ %02d ] : %lld\t\t(%03.2f%%)\n", i, s_flagCounts[i], (100.0 * s_flagCounts[i]) / total);
+    printf("\n\n");
+}
+uint64_t SamplingFlags::s_flagCounts[33];
+
+#else
+void SamplingFlags::start() {}
+void SamplingFlags::stop() {}
+#endif
+
+/*
+  Start with flag 16 set.
+  By doing this the monitoring of lower valued flags will be masked out
+  until flag 16 is explictly cleared.
+*/
+uint32_t SamplingFlags::s_flags = 1 << 15;
+
+
+#if PLATFORM(WIN_OS)
+
+static void sleepForMicroseconds(unsigned us)
+{
+    unsigned ms = us / 1000;
+    if (us && !ms)
+        ms = 1;
+    Sleep(ms);
+}
+
+#else 
+
+static void sleepForMicroseconds(unsigned us)
+{
+    usleep(us);
+}
+
+#endif
+
+static inline unsigned hertz2us(unsigned hertz)
+{
+    return 1000000 / hertz;
+}
+
+
+SamplingTool* SamplingTool::s_samplingTool = 0;
+
+
+bool SamplingThread::s_running = false;
+unsigned SamplingThread::s_hertz = 10000;
+ThreadIdentifier SamplingThread::s_samplingThread;
+
+void* SamplingThread::threadStartFunc(void*)
+{
+    while (s_running) {
+        sleepForMicroseconds(hertz2us(s_hertz));
+
+#if ENABLE(SAMPLING_FLAGS)
+        SamplingFlags::sample();
+#endif
+#if ENABLE(OPCODE_SAMPLING)
+        SamplingTool::sample();
+#endif
+    }
+
+    return 0;
+}
+
+
+void SamplingThread::start(unsigned hertz)
+{
+    ASSERT(!s_running);
+    s_running = true;
+    s_hertz = hertz;
+
+    s_samplingThread = createThread(threadStartFunc, 0, "JavaScriptCore::Sampler");
+}
+
+void SamplingThread::stop()
+{
+    ASSERT(s_running);
+    s_running = false;
+    waitForThreadCompletion(s_samplingThread, 0);
+}
+
+
 void ScopeSampleRecord::sample(CodeBlock* codeBlock, Instruction* vPC)
 {
@@ -59 +172 @@
 }
 
-#if PLATFORM(WIN_OS)
-
-static void sleepForMicroseconds(unsigned us)
-{
-    unsigned ms = us / 1000;
-    if (us && !ms)
-        ms = 1;
-    Sleep(ms);
-}
-
-#else 
-
-static void sleepForMicroseconds(unsigned us)
-{
-    usleep(us);
-}
-
-#endif
-
-static inline unsigned hertz2us(unsigned hertz)
-{
-    return 1000000 / hertz;
-}
-
-void SamplingTool::run()
-{
-    while (m_running) {
-        sleepForMicroseconds(hertz2us(m_hertz));
-
-        Sample sample(m_sample, m_codeBlock);
-        ++m_sampleCount;
-
-        if (sample.isNull())
-            continue;
-
-        if (!sample.inHostFunction()) {
-            unsigned opcodeID = m_interpreter->getOpcodeID(sample.vPC()[0].u.opcode);
-
-            ++m_opcodeSampleCount;
-            ++m_opcodeSamples[opcodeID];
-
-            if (sample.inCTIFunction())
-                m_opcodeSamplesInCTIFunctions[opcodeID]++;
-        }
+void SamplingTool::doRun()
+{
+    Sample sample(m_sample, m_codeBlock);
+    ++m_sampleCount;
+
+    if (sample.isNull())
+        return;
+
+    if (!sample.inHostFunction()) {
+        unsigned opcodeID = m_interpreter->getOpcodeID(sample.vPC()[0].u.opcode);
+
+        ++m_opcodeSampleCount;
+        ++m_opcodeSamples[opcodeID];
+
+        if (sample.inCTIFunction())
+            m_opcodeSamplesInCTIFunctions[opcodeID]++;
+    }
 
 #if ENABLE(CODEBLOCK_SAMPLING)
-        MutexLocker locker(m_scopeSampleMapMutex);
-        ScopeSampleRecord* record = m_scopeSampleMap->get(sample.codeBlock()->ownerNode());
-        ASSERT(record);
-        record->sample(sample.codeBlock(), sample.vPC());
-#endif
-    }
-}
-
-void* SamplingTool::threadStartFunc(void* samplingTool)
-{
-    reinterpret_cast<SamplingTool*>(samplingTool)->run();
-    return 0;
+    MutexLocker locker(m_scopeSampleMapMutex);
+    ScopeSampleRecord* record = m_scopeSampleMap->get(sample.codeBlock()->ownerNode());
+    ASSERT(record);
+    record->sample(sample.codeBlock(), sample.vPC());
+#endif
+}
+
+void SamplingTool::sample()
+{
+    s_samplingTool->doRun();
 }
 
@@ -125 +209 @@
 }
 
-void SamplingTool::start(unsigned hertz)
-{
-    ASSERT(!m_running);
-    m_running = true;
-    m_hertz = hertz;
-
-    m_samplingThread = createThread(threadStartFunc, this, "JavaScriptCore::Sampler");
-}
-
-void SamplingTool::stop()
-{
-    ASSERT(m_running);
-    m_running = false;
-    waitForThreadCompletion(m_samplingThread, 0);
+void SamplingTool::setup()
+{
+    s_samplingTool = this;
 }