JavaScriptCore/bytecode/SamplingTool.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef SamplingTool_h
  30 #define SamplingTool_h
  31
  32 #include <wtf/Assertions.h>
  33 #include <wtf/HashMap.h>
  34 #include <wtf/Threading.h>
  35
  36 #include "Nodes.h"
  37 #include "Opcode.h"
  38
  39 namespace JSC {
  40
  41     class ScriptExecutable;
  42
  43     class SamplingFlags {
  44         friend class JIT;
  45     public:
  46         static void start();
  47         static void stop();
  48
  49 #if ENABLE(SAMPLING_FLAGS)
  50         static void setFlag(unsigned flag)
  51         {
  52             ASSERT(flag >= 1);
  53             ASSERT(flag <= 32);
  54             s_flags |= 1u << (flag - 1);
  55         }
  56
  57         static void clearFlag(unsigned flag)
  58         {
  59             ASSERT(flag >= 1);
  60             ASSERT(flag <= 32);
  61             s_flags &= ~(1u << (flag - 1));
  62         }
  63
  64         static void sample();
  65
  66         class ScopedFlag {
  67         public:
  68             ScopedFlag(int flag)
  69                 : m_flag(flag)
  70             {
  71                 setFlag(flag);
  72             }
  73
  74             ~ScopedFlag()
  75             {
  76                 clearFlag(m_flag);
  77             }
  78
  79         private:
  80             int m_flag;
  81         };
  82
  83 #endif
  84     private:
  85         static uint32_t s_flags;
  86 #if ENABLE(SAMPLING_FLAGS)
  87         static uint64_t s_flagCounts[33];
  88 #endif
  89     };
  90
  91     class CodeBlock;
  92     class ExecState;
  93     class Interpreter;
  94     class ScopeNode;
  95     struct Instruction;
  96
  97     struct ScriptSampleRecord {
  98         ScriptSampleRecord(ScriptExecutable* executable)
  99             : m_executable(executable)
 100             , m_codeBlock(0)
 101             , m_sampleCount(0)
 102             , m_opcodeSampleCount(0)
 103             , m_samples(0)
 104             , m_size(0)
 105         {
 106         }
 107
 108         ~ScriptSampleRecord()
 109         {
 110             if (m_samples)
 111                 free(m_samples);
 112         }
 113
 114         void sample(CodeBlock*, Instruction*);
 115
 116         RefPtr<ScriptExecutable> m_executable;
 117         CodeBlock* m_codeBlock;
 118         int m_sampleCount;
 119         int m_opcodeSampleCount;
 120         int* m_samples;
 121         unsigned m_size;
 122     };
 123
 124     typedef WTF::HashMap<ScriptExecutable*, ScriptSampleRecord*> ScriptSampleRecordMap;
 125
 126     class SamplingThread {
 127     public:
 128         // Sampling thread state.
 129         static bool s_running;
 130         static unsigned s_hertz;
 131         static ThreadIdentifier s_samplingThread;
 132
 133         static void start(unsigned hertz=10000);
 134         static void stop();
 135
 136         static void* threadStartFunc(void*);
 137     };
 138
 139     class SamplingTool {
 140     public:
 141         friend struct CallRecord;
 142         friend class HostCallRecord;
 143
 144 #if ENABLE(OPCODE_SAMPLING)
 145         class CallRecord : public Noncopyable {
 146         public:
 147             CallRecord(SamplingTool* samplingTool)
 148                 : m_samplingTool(samplingTool)
 149                 , m_savedSample(samplingTool->m_sample)
 150                 , m_savedCodeBlock(samplingTool->m_codeBlock)
 151             {
 152             }
 153
 154             ~CallRecord()
 155             {
 156                 m_samplingTool->m_sample = m_savedSample;
 157                 m_samplingTool->m_codeBlock = m_savedCodeBlock;
 158             }
 159
 160         private:
 161             SamplingTool* m_samplingTool;
 162             intptr_t m_savedSample;
 163             CodeBlock* m_savedCodeBlock;
 164         };
 165
 166         class HostCallRecord : public CallRecord {
 167         public:
 168             HostCallRecord(SamplingTool* samplingTool)
 169                 : CallRecord(samplingTool)
 170             {
 171                 samplingTool->m_sample |= 0x1;
 172             }
 173         };
 174 #else
 175         class CallRecord : public Noncopyable {
 176         public:
 177             CallRecord(SamplingTool*)
 178             {
 179             }
 180         };
 181
 182         class HostCallRecord : public CallRecord {
 183         public:
 184             HostCallRecord(SamplingTool* samplingTool)
 185                 : CallRecord(samplingTool)
 186             {
 187             }
 188         };
 189 #endif
 190
 191         SamplingTool(Interpreter* interpreter)
 192             : m_interpreter(interpreter)
 193             , m_codeBlock(0)
 194             , m_sample(0)
 195             , m_sampleCount(0)
 196             , m_opcodeSampleCount(0)
 197 #if ENABLE(CODEBLOCK_SAMPLING)
 198             , m_scopeSampleMap(new ScriptSampleRecordMap())
 199 #endif
 200         {
 201             memset(m_opcodeSamples, 0, sizeof(m_opcodeSamples));
 202             memset(m_opcodeSamplesInCTIFunctions, 0, sizeof(m_opcodeSamplesInCTIFunctions));
 203         }
 204
 205         ~SamplingTool()
 206         {
 207 #if ENABLE(CODEBLOCK_SAMPLING)
 208             deleteAllValues(*m_scopeSampleMap);
 209 #endif
 210         }
 211
 212         void setup();
 213         void dump(ExecState*);
 214
 215         void notifyOfScope(ScriptExecutable* scope);
 216
 217         void sample(CodeBlock* codeBlock, Instruction* vPC)
 218         {
 219             ASSERT(!(reinterpret_cast<intptr_t>(vPC) & 0x3));
 220             m_codeBlock = codeBlock;
 221             m_sample = reinterpret_cast<intptr_t>(vPC);
 222         }
 223
 224         CodeBlock** codeBlockSlot() { return &m_codeBlock; }
 225         intptr_t* sampleSlot() { return &m_sample; }
 226
 227         void* encodeSample(Instruction* vPC, bool inCTIFunction = false, bool inHostFunction = false)
 228         {
 229             ASSERT(!(reinterpret_cast<intptr_t>(vPC) & 0x3));
 230             return reinterpret_cast<void*>(reinterpret_cast<intptr_t>(vPC) | (static_cast<intptr_t>(inCTIFunction) << 1) | static_cast<intptr_t>(inHostFunction));
 231         }
 232
 233         static void sample();
 234
 235     private:
 236         class Sample {
 237         public:
 238             Sample(volatile intptr_t sample, CodeBlock* volatile codeBlock)
 239                 : m_sample(sample)
 240                 , m_codeBlock(codeBlock)
 241             {
 242             }
 243
 244             bool isNull() { return !m_sample; }
 245             CodeBlock* codeBlock() { return m_codeBlock; }
 246             Instruction* vPC() { return reinterpret_cast<Instruction*>(m_sample & ~0x3); }
 247             bool inHostFunction() { return m_sample & 0x1; }
 248             bool inCTIFunction() { return m_sample & 0x2; }
 249
 250         private:
 251             intptr_t m_sample;
 252             CodeBlock* m_codeBlock;
 253         };
 254
 255         void doRun();
 256         static SamplingTool* s_samplingTool;
 257
 258         Interpreter* m_interpreter;
 259
 260         // State tracked by the main thread, used by the sampling thread.
 261         CodeBlock* m_codeBlock;
 262         intptr_t m_sample;
 263
 264         // Gathered sample data.
 265         long long m_sampleCount;
 266         long long m_opcodeSampleCount;
 267         unsigned m_opcodeSamples[numOpcodeIDs];
 268         unsigned m_opcodeSamplesInCTIFunctions[numOpcodeIDs];
 269
 270 #if ENABLE(CODEBLOCK_SAMPLING)
 271         Mutex m_scriptSampleMapMutex;
 272         OwnPtr<ScriptSampleRecordMap> m_scopeSampleMap;
 273 #endif
 274     };
 275
 276     // AbstractSamplingCounter:
 277     //
 278     // Implements a named set of counters, printed on exit if ENABLE(SAMPLING_COUNTERS).
 279     // See subclasses below, SamplingCounter, GlobalSamplingCounter and DeletableSamplingCounter.
 280     class AbstractSamplingCounter {
 281         friend class JIT;
 282         friend class DeletableSamplingCounter;
 283     public:
 284         void count(uint32_t count = 1)
 285         {
 286             m_counter += count;
 287         }
 288
 289         static void dump();
 290
 291     protected:
 292         // Effectively the contructor, however called lazily in the case of GlobalSamplingCounter.
 293         void init(const char* name)
 294         {
 295             m_counter = 0;
 296             m_name = name;
 297
 298             // Set m_next to point to the head of the chain, and inform whatever is
 299             // currently at the head that this node will now hold the pointer to it.
 300             m_next = s_abstractSamplingCounterChain;
 301             s_abstractSamplingCounterChain->m_referer = &m_next;
 302             // Add this node to the head of the list.
 303             s_abstractSamplingCounterChain = this;
 304             m_referer = &s_abstractSamplingCounterChain;
 305         }
 306
 307         int64_t m_counter;
 308         const char* m_name;
 309         AbstractSamplingCounter* m_next;
 310         // This is a pointer to the pointer to this node in the chain; used to
 311         // allow fast linked list deletion.
 312         AbstractSamplingCounter** m_referer;
 313         // Null object used to detect end of static chain.
 314         static AbstractSamplingCounter s_abstractSamplingCounterChainEnd;
 315         static AbstractSamplingCounter* s_abstractSamplingCounterChain;
 316         static bool s_completed;
 317     };
 318
 319 #if ENABLE(SAMPLING_COUNTERS)
 320     // SamplingCounter:
 321     //
 322     // This class is suitable and (hopefully!) convenient for cases where a counter is
 323     // required within the scope of a single function.  It can be instantiated as a
 324     // static variable since it contains a constructor but not a destructor (static
 325     // variables in WebKit cannot have destructors).
 326     //
 327     // For example:
 328     //
 329     // void someFunction()
 330     // {
 331     //     static SamplingCounter countMe("This is my counter.  There are many like it, but this one is mine.");
 332     //     countMe.count();
 333     //     // ...
 334     // }
 335     //
 336     class SamplingCounter : public AbstractSamplingCounter {
 337     public:
 338         SamplingCounter(const char* name) { init(name); }
 339     };
 340
 341     // GlobalSamplingCounter:
 342     //
 343     // This class is suitable for use where a counter is to be declared globally,
 344     // since it contains neither a constructor nor destructor.  Instead, ensure
 345     // that 'name()' is called to provide the counter with a name (and also to
 346     // allow it to be printed out on exit).
 347     //
 348     // GlobalSamplingCounter globalCounter;
 349     //
 350     // void firstFunction()
 351     // {
 352     //     // Put this within a function that is definitely called!
 353     //     // (Or alternatively alongside all calls to 'count()').
 354     //     globalCounter.name("I Name You Destroyer.");
 355     //     globalCounter.count();
 356     //     // ...
 357     // }
 358     //
 359     // void secondFunction()
 360     // {
 361     //     globalCounter.count();
 362     //     // ...
 363     // }
 364     //
 365     class GlobalSamplingCounter : public AbstractSamplingCounter {
 366     public:
 367         void name(const char* name)
 368         {
 369             // Global objects should be mapped in zero filled memory, so this should
 370             // be a safe (albeit not necessarily threadsafe) check for 'first call'.
 371             if (!m_next)
 372                 init(name);
 373         }
 374     };
 375
 376     // DeletableSamplingCounter:
 377     //
 378     // The above classes (SamplingCounter, GlobalSamplingCounter), are intended for
 379     // use within a global or static scope, and as such cannot have a destructor.
 380     // This means there is no convenient way for them to remove themselves from the
 381     // static list of counters, and should an instance of either class be freed
 382     // before 'dump()' has walked over the list it will potentially walk over an
 383     // invalid pointer.
 384     //
 385     // This class is intended for use where the counter may possibly be deleted before
 386     // the program exits.  Should this occur, the counter will print it's value to
 387     // stderr, and remove itself from the static list.  Example:
 388     //
 389     // DeletableSamplingCounter* counter = new DeletableSamplingCounter("The Counter With No Name");
 390     // counter->count();
 391     // delete counter;
 392     //
 393     class DeletableSamplingCounter : public AbstractSamplingCounter {
 394     public:
 395         DeletableSamplingCounter(const char* name) { init(name); }
 396
 397         ~DeletableSamplingCounter()
 398         {
 399             if (!s_completed)
 400                 fprintf(stderr, "DeletableSamplingCounter \"%s\" deleted early (with count %lld)\n", m_name, m_counter);
 401             // Our m_referer pointer should know where the pointer to this node is,
 402             // and m_next should know that this node is the previous node in the list.
 403             ASSERT(*m_referer == this);
 404             ASSERT(m_next->m_referer == &m_next);
 405             // Remove this node from the list, and inform m_next that we have done so.
 406             m_next->m_referer = m_referer;
 407             *m_referer = m_next;
 408         }
 409     };
 410 #endif
 411
 412 } // namespace JSC
 413
 414 #endif // SamplingTool_h