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 415
