⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 181547 in webkit


Ignore:
Timestamp:
Mar 16, 2015, 5:14:19 AM (11 years ago)
Author:
Carlos Garcia Campos
Message:

Merge r181481 - Introduce WTF::Atomic to wrap std::atomic for a friendlier CAS.
<​https://webkit.org/b/142661>

Reviewed by Filip Pizlo.

Source/JavaScriptCore:

Changed CodeBlock, and the DFG's crashLock to use WTF::Atomic instead of
std::atomic.

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):
(JSC::CodeBlock::visitAggregate):

  • bytecode/CodeBlock.h:
  • dfg/DFGCommon.cpp:

(JSC::DFG::startCrashing):

Source/WTF:

The CAS functions provided by std::atomic takes a reference to the expected
value and modifies it if the CAS fails. However, in a lot of our CAS usage,
we don't want the expected value to change. The solution to this is to
provide a WTF::Atomic struct that wraps std::atomic, and provide CAS
methods that won't alter the expected value if the CAS fails.

The method names in WTF::Atomic are chosen to be identical to those
in std::atomic so that WTF::Atomic can be a simple drop in replacement
for std::atomic.

Also changed ByteSpinLock to use WTF::Atomic instead of std::atomic.

  • wtf/Atomics.h:

(WTF::Atomic::load):
(WTF::Atomic::store):
(WTF::Atomic::compare_exchange_weak):
(WTF::Atomic::compare_exchange_strong):

  • wtf/ByteSpinLock.h:

(WTF::ByteSpinLock::ByteSpinLock):
(WTF::ByteSpinLock::lock):

Location:
releases/WebKitGTK/webkit-2.8/Source
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • releases/WebKitGTK/webkit-2.8/Source/JavaScriptCore/ChangeLog

    r181545 r181547  
     12015-03-13  Mark Lam  <mark.lam@apple.com>
     2
     3        Introduce WTF::Atomic to wrap std::atomic for a friendlier CAS.
     4        <https://webkit.org/b/142661>
     5
     6        Reviewed by Filip Pizlo.
     7
     8        Changed CodeBlock, and the DFG's crashLock to use WTF::Atomic instead of
     9        std::atomic.
     10
     11        * bytecode/CodeBlock.cpp:
     12        (JSC::CodeBlock::CodeBlock):
     13        (JSC::CodeBlock::visitAggregate):
     14        * bytecode/CodeBlock.h:
     15        * dfg/DFGCommon.cpp:
     16        (JSC::DFG::startCrashing):
     17
    1182015-03-12  Mark Lam  <mark.lam@apple.com>
    219

  • releases/WebKitGTK/webkit-2.8/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r181541 r181547  
    16301630    , m_needsActivation(other.m_needsActivation)
    16311631    , m_mayBeExecuting(false)
    1632     , m_visitAggregateHasBeenCalled(false)
    16331632    , m_source(other.m_source)
    16341633    , m_sourceOffset(other.m_sourceOffset)
    … …  
    16461645#endif
    16471646{
     1647    m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed);
     1648
    16481649    ASSERT(m_heap->isDeferred());
    16491650    ASSERT(m_scopeRegister.isLocal());
    … …  
    16911692    , m_needsActivation(unlinkedCodeBlock->hasActivationRegister() && unlinkedCodeBlock->codeType() == FunctionCode)
    16921693    , m_mayBeExecuting(false)
    1693     , m_visitAggregateHasBeenCalled(false)
    16941694    , m_source(sourceProvider)
    16951695    , m_sourceOffset(sourceOffset)
    … …  
    17031703#endif
    17041704{
     1705    m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed);
     1706
    17051707    ASSERT(m_heap->isDeferred());
    17061708    ASSERT(m_scopeRegister.isLocal());
    … …  
    22092211    // To this end, use an atomic operation to check (and set) if I've been called already.
    22102212    // Only one thread may proceed past this point - whichever one wins the atomic set race.
    2211     bool expected = false;
    2212     bool setByMe = m_visitAggregateHasBeenCalled.compare_exchange_strong(expected, true, std::memory_order_acquire);
     2213    bool setByMe = m_visitAggregateHasBeenCalled.compare_exchange_strong(false, true, std::memory_order_acquire);
    22132214    if (!setByMe)
    22142215        return;

  • releases/WebKitGTK/webkit-2.8/Source/JavaScriptCore/bytecode/CodeBlock.h

    r181541 r181547  
    10571057    bool m_needsActivation;
    10581058    bool m_mayBeExecuting;
    1059     std::atomic<bool> m_visitAggregateHasBeenCalled;
     1059    Atomic<bool> m_visitAggregateHasBeenCalled;
    10601060
    10611061    RefPtr<SourceProvider> m_source;

  • releases/WebKitGTK/webkit-2.8/Source/JavaScriptCore/dfg/DFGCommon.cpp

    r181545 r181547  
    3434namespace JSC { namespace DFG {
    3535
    36 static std::atomic<unsigned> crashLock;
     36static Atomic<unsigned> crashLock;
    3737
    3838void startCrashing()
    3939{
    40     unsigned expected = 0;
    41     while (!crashLock.compare_exchange_weak(expected, 1, std::memory_order_acquire)) {
     40    while (!crashLock.compare_exchange_weak(0, 1, std::memory_order_acquire))
    4241        std::this_thread::yield();
    43         expected = 0;
    44     }
    4542}
    4643

  • releases/WebKitGTK/webkit-2.8/Source/WTF/ChangeLog

    r181544 r181547  
     12015-03-13  Mark Lam  <mark.lam@apple.com>
     2
     3        Introduce WTF::Atomic to wrap std::atomic for a friendlier CAS.
     4        <https://webkit.org/b/142661>
     5
     6        Reviewed by Filip Pizlo.
     7
     8        The CAS functions provided by std::atomic takes a reference to the expected
     9        value and modifies it if the CAS fails.  However, in a lot of our CAS usage,
     10        we don't want the expected value to change.  The solution to this is to
     11        provide a WTF::Atomic struct that wraps std::atomic, and provide CAS
     12        methods that won't alter the expected value if the CAS fails.
     13
     14        The method names in WTF::Atomic are chosen to be identical to those
     15        in std::atomic so that WTF::Atomic can be a simple drop in replacement
     16        for std::atomic.
     17
     18        Also changed ByteSpinLock to use WTF::Atomic instead of std::atomic.
     19
     20        * wtf/Atomics.h:
     21        (WTF::Atomic::load):
     22        (WTF::Atomic::store):
     23        (WTF::Atomic::compare_exchange_weak):
     24        (WTF::Atomic::compare_exchange_strong):
     25        * wtf/ByteSpinLock.h:
     26        (WTF::ByteSpinLock::ByteSpinLock):
     27        (WTF::ByteSpinLock::lock):
     28
    1292015-03-14  Michael Saboff  <msaboff@apple.com>
    230

  • releases/WebKitGTK/webkit-2.8/Source/WTF/wtf/Atomics.h

    r181375 r181547  
    11/*
    2  * Copyright (C) 2007, 2008, 2010, 2012, 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007-2008, 2010, 2012-2013, 2015 Apple Inc. All rights reserved.
    33 * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
    44 *
    … …  
    6060#define Atomics_h
    6161
     62#include <atomic>
    6263#include <wtf/StdLibExtras.h>
    6364
    … …  
    7172
    7273namespace WTF {
     74
     75// Atomic wraps around std::atomic with the sole purpose of making the compare_exchange
     76// operations not alter the expected value. This is more in line with how we typically
     77// use CAS in our code.
     78//
     79// Atomic is a struct without explicitly defined constructors so that it can be
     80// initialized at compile time.
     81
     82template<typename T>
     83struct Atomic {
     84
     85    T load(std::memory_order order) const { return value.load(order); }
     86
     87    void store(T desired, std::memory_order order) { value.store(desired, order); }
     88
     89    bool compare_exchange_weak(T expected, T desired, std::memory_order order)
     90    {
     91        T expectedOrActual = expected;
     92        return value.compare_exchange_weak(expectedOrActual, desired, order);
     93    }
     94
     95    bool compare_exchange_strong(T expected, T desired, std::memory_order order)
     96    {
     97        T expectedOrActual = expected;
     98        return value.compare_exchange_strong(expectedOrActual, desired, order);
     99    }
     100
     101    std::atomic<T> value;
     102};
    73103
    74104#if OS(WINDOWS)
    … …  
    346376} // namespace WTF
    347377
     378using WTF::Atomic;
     379
    348380#endif // Atomics_h

  • releases/WebKitGTK/webkit-2.8/Source/WTF/wtf/ByteSpinLock.h

    r181543 r181547  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2727#define ByteSpinLock_h
    2828
    29 #include <atomic>
    3029#include <thread>
    3130#include <wtf/Assertions.h>
     31#include <wtf/Atomics.h>
    3232#include <wtf/Locker.h>
    3333#include <wtf/Noncopyable.h>
    … …  
    3939public:
    4040    ByteSpinLock()
    41         : m_lock(false)
    4241    {
     42        m_lock.store(false, std::memory_order_relaxed);
    4343    }
    4444
    4545    void lock()
    4646    {
    47         bool expected = false;
    48         while (!m_lock.compare_exchange_weak(expected, true, std::memory_order_acquire)) {
     47        while (!m_lock.compare_exchange_weak(false, true, std::memory_order_acquire))
    4948            std::this_thread::yield();
    50             expected = false;
    51         }
    5249    }
    5350   
    … …  
    6057   
    6158private:
    62     std::atomic<bool> m_lock;
     59    Atomic<bool> m_lock;
    6360};
    6461
Note: See TracChangeset for help on using the changeset viewer.