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