Changeset 99374 in webkit for trunk/Source/JavaScriptCore

Timestamp:

Nov 6, 2011, 3:39:12 AM (14 years ago)

Author:

[email protected]

Message:

JSC should be able to sample itself in a more flexible way than just sampling flags
​https://bugs.webkit.org/show_bug.cgi?id=71522

Source/JavaScriptCore:

Reviewed by Gavin Barraclough.

Added a construct that looks like SamplingRegion samplingRegion("name").

• JavaScriptCore.exp:
• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/SamplingTool.cpp:

(JSC::SamplingRegion::Locker::Locker):
(JSC::SamplingRegion::Locker::~Locker):
(JSC::SamplingRegion::sample):
(JSC::SamplingRegion::dump):
(JSC::SamplingRegion::dumpInternal):
(JSC::SamplingThread::threadStartFunc):

• bytecode/SamplingTool.h:

(JSC::SamplingRegion::SamplingRegion):
(JSC::SamplingRegion::~SamplingRegion):
(JSC::SamplingRegion::exchangeCurrent):

• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::generate):

• dfg/DFGDriver.cpp:

(JSC::DFG::compile):

• heap/Heap.cpp:

(JSC::Heap::markRoots):
(JSC::Heap::collect):

• heap/VTableSpectrum.cpp:

(JSC::VTableSpectrum::countVPtr):
(JSC::VTableSpectrum::dump):

• heap/VTableSpectrum.h:
• jsc.cpp:

(main):
(runWithScripts):

• parser/Parser.h:

(JSC::parse):

• runtime/Executable.cpp:

(JSC::EvalExecutable::compileInternal):
(JSC::ProgramExecutable::compileInternal):
(JSC::FunctionExecutable::compileForCallInternal):
(JSC::FunctionExecutable::compileForConstructInternal):

• wtf/Atomics.h:

(WTF::weakCompareAndSwap):

• wtf/Platform.h:
• wtf/Spectrum.h: Added.

(WTF::Spectrum::Spectrum):
(WTF::Spectrum::add):
(WTF::Spectrum::get):
(WTF::Spectrum::begin):
(WTF::Spectrum::end):
(WTF::Spectrum::KeyAndCount::KeyAndCount):
(WTF::Spectrum::KeyAndCount::operator<):
(WTF::Spectrum::buildList):

• wtf/wtf.pri:

Source/JavaScriptGlue:

Reviewed by Gavin Barraclough.

• ForwardingHeaders/wtf/Spectrum.h: Added.

Source/WebCore:

Reviewed by Gavin Barraclough.

No new tests, since no functionality changed.

• ForwardingHeaders/wtf/Spectrum.h: Added.

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• JavaScriptCore.exp (modified) (1 diff)
• JavaScriptCore.xcodeproj/project.pbxproj (modified) (4 diffs)
• bytecode/SamplingTool.cpp (modified) (2 diffs)
• bytecode/SamplingTool.h (modified) (2 diffs)
• bytecompiler/BytecodeGenerator.cpp (modified) (1 diff)
• dfg/DFGDriver.cpp (modified) (1 diff)
• heap/Heap.cpp (modified) (3 diffs)
• heap/VTableSpectrum.cpp (modified) (3 diffs)
• heap/VTableSpectrum.h (modified) (3 diffs)
• jsc.cpp (modified) (3 diffs)
• parser/Parser.h (modified) (1 diff)
• runtime/Executable.cpp (modified) (4 diffs)
• wtf/Atomics.h (modified) (2 diffs)
• wtf/Platform.h (modified) (2 diffs)
• wtf/Spectrum.h (added)
• wtf/wtf.pri (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-11-03  Filip Pizlo  <[email protected]>
+
+        JSC should be able to sample itself in a more flexible way than just sampling flags
+        https://bugs.webkit.org/show_bug.cgi?id=71522
+
+        Reviewed by Gavin Barraclough.
+        
+        Added a construct that looks like SamplingRegion samplingRegion("name").
+
+        * JavaScriptCore.exp:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * bytecode/SamplingTool.cpp:
+        (JSC::SamplingRegion::Locker::Locker):
+        (JSC::SamplingRegion::Locker::~Locker):
+        (JSC::SamplingRegion::sample):
+        (JSC::SamplingRegion::dump):
+        (JSC::SamplingRegion::dumpInternal):
+        (JSC::SamplingThread::threadStartFunc):
+        * bytecode/SamplingTool.h:
+        (JSC::SamplingRegion::SamplingRegion):
+        (JSC::SamplingRegion::~SamplingRegion):
+        (JSC::SamplingRegion::exchangeCurrent):
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::generate):
+        * dfg/DFGDriver.cpp:
+        (JSC::DFG::compile):
+        * heap/Heap.cpp:
+        (JSC::Heap::markRoots):
+        (JSC::Heap::collect):
+        * heap/VTableSpectrum.cpp:
+        (JSC::VTableSpectrum::countVPtr):
+        (JSC::VTableSpectrum::dump):
+        * heap/VTableSpectrum.h:
+        * jsc.cpp:
+        (main):
+        (runWithScripts):
+        * parser/Parser.h:
+        (JSC::parse):
+        * runtime/Executable.cpp:
+        (JSC::EvalExecutable::compileInternal):
+        (JSC::ProgramExecutable::compileInternal):
+        (JSC::FunctionExecutable::compileForCallInternal):
+        (JSC::FunctionExecutable::compileForConstructInternal):
+        * wtf/Atomics.h:
+        (WTF::weakCompareAndSwap):
+        * wtf/Platform.h:
+        * wtf/Spectrum.h: Added.
+        (WTF::Spectrum::Spectrum):
+        (WTF::Spectrum::add):
+        (WTF::Spectrum::get):
+        (WTF::Spectrum::begin):
+        (WTF::Spectrum::end):
+        (WTF::Spectrum::KeyAndCount::KeyAndCount):
+        (WTF::Spectrum::KeyAndCount::operator<):
+        (WTF::Spectrum::buildList):
+        * wtf/wtf.pri:
+
 2011-11-05  Sam Weinig  <[email protected]>
 

trunk/Source/JavaScriptCore/JavaScriptCore.exp

@@ -180 +180 @@
 __ZN3JSC14MachineThreads16addCurrentThreadEv
 __ZN3JSC14MarkStackArray6expandEv
+__ZN3JSC14SamplingRegion4dumpEv
 __ZN3JSC14SamplingThread4stopEv
 __ZN3JSC14SamplingThread5startEj

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

@@ -51 +51 @@
                 0F16D726142C39C000CF784A /* BitVector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F16D724142C39A200CF784A /* BitVector.cpp */; };
                 0F242DA713F3B1E8007ADD4C /* WeakReferenceHarvester.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F242DA513F3B1BB007ADD4C /* WeakReferenceHarvester.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                0F2E5BF7146357D5003EB2EB /* Spectrum.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F2E5BF5146357D2003EB2EB /* Spectrum.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0F426A481460CBB300131F8F /* ValueRecovery.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F426A451460CBAB00131F8F /* ValueRecovery.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0F426A491460CBB700131F8F /* VirtualRegister.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F426A461460CBAB00131F8F /* VirtualRegister.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -814 +815 @@
                 0F16D724142C39A200CF784A /* BitVector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BitVector.cpp; sourceTree = "<group>"; };
                 0F242DA513F3B1BB007ADD4C /* WeakReferenceHarvester.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WeakReferenceHarvester.h; sourceTree = "<group>"; };
+                0F2E5BF5146357D2003EB2EB /* Spectrum.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Spectrum.h; sourceTree = "<group>"; };
                 0F426A451460CBAB00131F8F /* ValueRecovery.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ValueRecovery.h; sourceTree = "<group>"; };
                 0F426A461460CBAB00131F8F /* VirtualRegister.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VirtualRegister.h; sourceTree = "<group>"; };
@@ -1856 +1858 @@
                         isa = PBXGroup;
                         children = (
+                                0F2E5BF5146357D2003EB2EB /* Spectrum.h */,
                                 0FD52AAC1430359D0026DC9F /* UnionFind.h */,
                                 0F636D9F142D27D200B2E66A /* PackedIntVector.h */,
@@ -2898 +2901 @@
                                 0F426A491460CBB700131F8F /* VirtualRegister.h in Headers */,
                                 0F426A4B1460CD6E00131F8F /* DataFormat.h in Headers */,
+                                0F2E5BF7146357D5003EB2EB /* Spectrum.h in Headers */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;

trunk/Source/JavaScriptCore/bytecode/SamplingTool.cpp

@@ -84 +84 @@
 #endif
 
+#if ENABLE(SAMPLING_REGIONS)
+volatile uintptr_t SamplingRegion::s_currentOrReserved;
+Spectrum<const char*>* SamplingRegion::s_spectrum;
+unsigned long SamplingRegion::s_noneOfTheAbove;
+unsigned SamplingRegion::s_numberOfSamplesSinceDump;
+
+SamplingRegion::Locker::Locker()
+{
+    uintptr_t previous;
+    while (true) {
+        previous = s_currentOrReserved;
+        if (previous & 1) {
+#if OS(UNIX)
+            sched_yield();
+#endif
+            continue;
+        }
+        if (WTF::weakCompareAndSwap(&s_currentOrReserved, previous, previous | 1))
+            break;
+    }
+}
+
+SamplingRegion::Locker::~Locker()
+{
+    // We don't need the CAS, but we do it out of an
+    // abundance of caution (and because it gives us a memory fence, which is
+    // never bad).
+    uintptr_t previous;
+    do {
+        previous = s_currentOrReserved;
+    } while (!WTF::weakCompareAndSwap(&s_currentOrReserved, previous, previous & ~1));
+}
+
+void SamplingRegion::sample()
+{
+    // Make sure we lock s_current.
+    Locker locker;
+    
+    // Create a spectrum if we don't have one already.
+    if (!s_spectrum)
+        s_spectrum = new Spectrum<const char*>();
+    
+    ASSERT(s_currentOrReserved & 1);
+    
+    // Walk the region stack, and record each region we see.
+    SamplingRegion* region = bitwise_cast<SamplingRegion*>(s_currentOrReserved & ~1);
+    if (region) {
+        for (; region; region = region->m_previous)
+            s_spectrum->add(region->m_name);
+    } else
+        s_noneOfTheAbove++;
+    
+    if (s_numberOfSamplesSinceDump++ == SamplingThread::s_hertz) {
+        s_numberOfSamplesSinceDump = 0;
+        dumpInternal();
+    }
+}
+
+void SamplingRegion::dump()
+{
+    Locker locker;
+    
+    dumpInternal();
+}
+
+void SamplingRegion::dumpInternal()
+{
+    if (!s_spectrum) {
+        printf("\nSamplingRegion: was never sampled.\n\n");
+        return;
+    }
+    
+    Vector<Spectrum<const char*>::KeyAndCount> list = s_spectrum->buildList();
+    
+    unsigned long total = s_noneOfTheAbove;
+    for (unsigned i = list.size(); i--;)
+        total += list[i].count;
+    
+    printf("\nSamplingRegion: sample counts for regions: (%lu samples)\n", total);
+
+    for (unsigned i = list.size(); i--;)
+        printf("    %3.2lf%%  %s\n", (100.0 * list[i].count) / total, list[i].key);
+}
+#else // ENABLE(SAMPLING_REGIONS)
+void SamplingRegion::dump() { }
+#endif // ENABLE(SAMPLING_REGIONS)
+
 /*
   Start with flag 16 set.
@@ -131 +218 @@
 #if ENABLE(SAMPLING_FLAGS)
         SamplingFlags::sample();
+#endif
+#if ENABLE(SAMPLING_REGIONS)
+        SamplingRegion::sample();
 #endif
 #if ENABLE(OPCODE_SAMPLING)

trunk/Source/JavaScriptCore/bytecode/SamplingTool.h

@@ -35 +35 @@
 #include "SamplingCounter.h"
 #include <wtf/Assertions.h>
+#include <wtf/Atomics.h>
 #include <wtf/HashMap.h>
+#include <wtf/MainThread.h>
 #include <wtf/Threading.h>
 
@@ -93 +95 @@
 #endif
     };
+
+#if ENABLE(SAMPLING_REGIONS)
+    class SamplingRegion {
+    public:
+        // Create a scoped sampling region using a C string constant name that describes
+        // what you are doing. This must be a string constant that persists for the
+        // lifetime of the process and is immutable.
+        SamplingRegion(const char* name)
+        {
+            if (!isMainThread()) {
+                m_name = 0;
+                return;
+            }
+            
+            m_name = name;
+            exchangeCurrent(this, &m_previous);
+            ASSERT(!m_previous || m_previous > this);
+        }
+        
+        ~SamplingRegion()
+        {
+            if (!m_name)
+                return;
+            
+            ASSERT(bitwise_cast<SamplingRegion*>(s_currentOrReserved & ~1) == this);
+            exchangeCurrent(m_previous);
+        }
+        
+        static void sample();
+        
+        static void dump();
+        
+    private:
+        const char* m_name;
+        SamplingRegion* m_previous;
+
+        static void exchangeCurrent(SamplingRegion* current, SamplingRegion** previousPtr = 0)
+        {
+            uintptr_t previous;
+            while (true) {
+                previous = s_currentOrReserved;
+                
+                // If it's reserved (i.e. sampling thread is reading it), loop around.
+                if (previous & 1) {
+#if OS(UNIX)
+                    sched_yield();
+#endif
+                    continue;
+                }
+                
+                // If we're going to CAS, then make sure previous is set.
+                if (previousPtr)
+                    *previousPtr = bitwise_cast<SamplingRegion*>(previous);
+                
+                if (WTF::weakCompareAndSwap(&s_currentOrReserved, previous, bitwise_cast<uintptr_t>(current)))
+                    break;
+            }
+        }
+        
+        static void dumpInternal();
+
+        class Locker {
+        public:
+            Locker();
+            ~Locker();
+        };
+
+        static volatile uintptr_t s_currentOrReserved;
+        
+        // rely on identity hashing of string constants
+        static Spectrum<const char*>* s_spectrum;
+        
+        static unsigned long s_noneOfTheAbove;
+        
+        static unsigned s_numberOfSamplesSinceDump;
+    };
+#else // ENABLE(SAMPLING_REGIONS)
+    class SamplingRegion {
+    public:
+        SamplingRegion(const char*) { }
+        void dump();
+    };
+#endif // ENABLE(SAMPLING_REGIONS)
 
     class CodeBlock;

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -141 +141 @@
 JSObject* BytecodeGenerator::generate()
 {
+    SamplingRegion samplingRegion("Bytecode Generation");
+    
     m_codeBlock->setThisRegister(m_thisRegister.index());
 

trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

@@ -38 +38 @@
 inline bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlock, JITCode& jitCode, MacroAssemblerCodePtr* jitCodeWithArityCheck)
 {
+    SamplingRegion samplingRegion("DFG Compilation (Driver)");
+    
     JSGlobalData* globalData = &exec->globalData();
     Graph dfg;

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -554 +554 @@
 void Heap::markRoots(bool fullGC)
 {
+    SamplingRegion samplingRegion("Garbage Collection: Tracing");
+
     COND_GCPHASE(fullGC, MarkFullRoots, MarkYoungRoots);
     UNUSED_PARAM(fullGC);
@@ -760 +762 @@
 void Heap::collect(SweepToggle sweepToggle)
 {
+    SamplingRegion samplingRegion("Garbage Collection");
+    
     GCPHASE(Collect);
     ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable());
@@ -793 +797 @@
 
     if (sweepToggle == DoSweep) {
+        SamplingRegion samplingRegion("Garbage Collection: Sweeping");
         GCPHASE(Sweeping);
         sweep();

trunk/Source/JavaScriptCore/heap/VTableSpectrum.cpp

@@ -50 +50 @@
 void VTableSpectrum::countVPtr(void* vTablePointer)
 {
-    std::pair<HashMap<void*, unsigned long>::iterator, bool> result = m_map.add(vTablePointer, 1);
-    if (!result.second)
-        result.first->second++;
+    add(vTablePointer);
 }
 
@@ -60 +58 @@
 }
 
-struct VTableAndCount {
-    void* vtable;
-    unsigned long count;
-    
-    VTableAndCount() { }
-    
-    VTableAndCount(void* vtable, unsigned long count)
-        : vtable(vtable)
-        , count(count)
-    {
-    }
-    
-    bool operator<(const VTableAndCount& other) const
-    {
-        if (count != other.count)
-            return count < other.count;
-        return vtable > other.vtable; // this results in lower-addressed vtables being printed first
-    }
-};
-
 void VTableSpectrum::dump(FILE* output, const char* comment)
 {
     fprintf(output, "%s:\n", comment);
     
-    HashMap<void*, unsigned long>::iterator begin = m_map.begin();
-    HashMap<void*, unsigned long>::iterator end = m_map.end();
-    
-    Vector<VTableAndCount, 0> list;
-    
-    for (HashMap<void*, unsigned long>::iterator iter = begin; iter != end; ++iter)
-        list.append(VTableAndCount(iter->first, iter->second));
-    
-    std::sort(list.begin(), list.end());
+    Vector<KeyAndCount> list = buildList();
     
     for (size_t index = list.size(); index-- > 0;) {
-        VTableAndCount item = list.at(index);
+        KeyAndCount item = list.at(index);
 #if PLATFORM(MAC)
         Dl_info info;
-        if (dladdr(item.vtable, &info)) {
+        if (dladdr(item.key, &info)) {
             char* findResult = strrchr(info.dli_fname, '/');
             const char* strippedFileName;
@@ -107 +77 @@
                 strippedFileName = info.dli_fname;
             
-            fprintf(output, "    %s:%s(%p): %lu\n", strippedFileName, info.dli_sname, item.vtable, item.count);
+            fprintf(output, "    %s:%s(%p): %lu\n", strippedFileName, info.dli_sname, item.key, item.count);
             continue;
         }
 #endif
-        fprintf(output, "    %p: %lu\n", item.vtable, item.count);
+        fprintf(output, "    %p: %lu\n", item.key, item.count);
     }
     

trunk/Source/JavaScriptCore/heap/VTableSpectrum.h

@@ -28 +28 @@
 
 #include <stdio.h>
-#include <wtf/HashMap.h>
+#include <wtf/Spectrum.h>
 
 namespace JSC {
@@ -34 +34 @@
 class JSCell;
 
-class VTableSpectrum {
+class VTableSpectrum: Spectrum<void*> {
 public:
     VTableSpectrum();
@@ -43 +43 @@
     
     void dump(FILE* output, const char* comment);
-    
-private:
-    HashMap<void*, unsigned long> m_map;
 };
 

trunk/Source/JavaScriptCore/jsc.cpp

@@ -32 +32 @@
 #include "JSLock.h"
 #include "JSString.h"
+#include "MainThread.h"
 #include "SamplingTool.h"
 #include <math.h>
@@ -405 +406 @@
 
     // Initialize JSC before getting JSGlobalData.
+    WTF::initializeMainThread();
     JSC::initializeThreading();
 
@@ -472 +474 @@
 #if ENABLE(SAMPLING_FLAGS)
     SamplingFlags::stop();
+#endif
+#if ENABLE(SAMPLING_REGIONS)
+    SamplingRegion::dump();
 #endif
     globalData.dumpSampleData(globalObject->globalExec());

trunk/Source/JavaScriptCore/parser/Parser.h

@@ -1030 +1030 @@
 PassRefPtr<ParsedNode> parse(JSGlobalData* globalData, JSGlobalObject* lexicalGlobalObject, const SourceCode& source, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode parserMode, Debugger* debugger, ExecState* execState, JSObject** exception)
 {
+    SamplingRegion samplingRegion("Parsing");
     Parser parser(globalData, source, parameters, strictness, parserMode);
     return parser.parse<ParsedNode>(lexicalGlobalObject, debugger, execState, exception);

trunk/Source/JavaScriptCore/runtime/Executable.cpp

@@ -149 +149 @@
 JSObject* EvalExecutable::compileInternal(ExecState* exec, ScopeChainNode* scopeChainNode, JITCode::JITType jitType)
 {
+    SamplingRegion samplingRegion(jitType == JITCode::BaselineJIT ? "Baseline Compilation (TOTAL)" : "DFG Compilation (TOTAL)");
+    
 #if !ENABLE(JIT)
     UNUSED_PARAM(jitType);
@@ -281 +283 @@
 JSObject* ProgramExecutable::compileInternal(ExecState* exec, ScopeChainNode* scopeChainNode, JITCode::JITType jitType)
 {
+    SamplingRegion samplingRegion(jitType == JITCode::BaselineJIT ? "Baseline Compilation (TOTAL)" : "DFG Compilation (TOTAL)");
+    
 #if !ENABLE(JIT)
     UNUSED_PARAM(jitType);
@@ -456 +460 @@
 JSObject* FunctionExecutable::compileForCallInternal(ExecState* exec, ScopeChainNode* scopeChainNode, JITCode::JITType jitType)
 {
+    SamplingRegion samplingRegion(jitType == JITCode::BaselineJIT ? "Baseline Compilation (TOTAL)" : "DFG Compilation (TOTAL)");
+    
 #if !ENABLE(JIT)
     UNUSED_PARAM(exec);
@@ -516 +522 @@
 JSObject* FunctionExecutable::compileForConstructInternal(ExecState* exec, ScopeChainNode* scopeChainNode, JITCode::JITType jitType)
 {
+    SamplingRegion samplingRegion(jitType == JITCode::BaselineJIT ? "Baseline Compilation (TOTAL)" : "DFG Compilation (TOTAL)");
+    
 #if !ENABLE(JIT)
     UNUSED_PARAM(jitType);

trunk/Source/JavaScriptCore/wtf/Atomics.h

@@ -127 +127 @@
         "lock; cmpxchgl %3, %2\n\t"
         "sete %1"
-        : "+a"(expected), "=r"(result), "+m"(*location)
+        : "+a"(expected), "=q"(result), "+m"(*location)
         : "r"(newValue)
         : "memory"
@@ -141 +141 @@
 }
 
+inline bool weakCompareAndSwap(void*volatile* location, void* expected, void* newValue)
+{
+    // FIXME: Implement COMPARE_AND_SWAP on other architectures and compilers. Currently
+    // it only works on X86 or X86_64 with a GCC-style compiler.
+#if ENABLE(COMPARE_AND_SWAP)
+    bool result;
+    asm volatile(
+#if CPU(X86_64)
+        "lock; cmpxchgq %3, %2\n\t"
+#else
+        "lock; cmpxchgl %3, %2\n\t"
+#endif
+        "sete %1"
+        : "+a"(expected), "=q"(result), "+m"(*location)
+        : "r"(newValue)
+        : "memory"
+        );
+    return result;
+#else // ENABLE(COMPARE_AND_SWAP)
+    UNUSED_PARAM(location);
+    UNUSED_PARAM(expected);
+    UNUSED_PARAM(newValue);
+    CRASH();
+    return 0;
+#endif // ENABLE(COMPARE_AND_SWAP)
+}
+
+inline bool weakCompareAndSwap(volatile uintptr_t* location, uintptr_t expected, uintptr_t newValue)
+{
+    return weakCompareAndSwap(reinterpret_cast<void*volatile*>(location), reinterpret_cast<void*>(expected), reinterpret_cast<void*>(newValue));
+}
+
 } // namespace WTF
 

trunk/Source/JavaScriptCore/wtf/Platform.h

@@ -809 +809 @@
 #define ENABLE_SAMPLING_COUNTERS 0
 #define ENABLE_SAMPLING_FLAGS 0
+#define ENABLE_SAMPLING_REGIONS 0
 #define ENABLE_OPCODE_SAMPLING 0
 #define ENABLE_CODEBLOCK_SAMPLING 0
@@ -814 +815 @@
 #error "CODEBLOCK_SAMPLING requires OPCODE_SAMPLING"
 #endif
-#if ENABLE(OPCODE_SAMPLING) || ENABLE(SAMPLING_FLAGS)
+#if ENABLE(OPCODE_SAMPLING) || ENABLE(SAMPLING_FLAGS) || ENABLE(SAMPLING_REGIONS)
 #define ENABLE_SAMPLING_THREAD 1
 #endif

trunk/Source/JavaScriptCore/wtf/wtf.pri

@@ -98 +98 @@
     wtf/RetainPtr.h \
     wtf/SHA1.h \
+    wtf/Spectrum.h \
     wtf/StackBounds.h \
     wtf/StaticConstructors.h \