Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (188143 => 188144)
--- trunk/Source/_javascript_Core/ChangeLog 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/ChangeLog 2015-08-07 18:51:00 UTC (rev 188144)
@@ -244,31 +244,6 @@
(getSym1):
(getSym2):
-2015-08-05 Filip Pizlo <[email protected]>
-
- Lightweight locks should be adaptive
- https://bugs.webkit.org/show_bug.cgi?id=147545
-
- Reviewed by Geoffrey Garen.
-
- * heap/CopiedBlock.h:
- (JSC::CopiedBlock::workListLock):
- * heap/CopiedBlockInlines.h:
- (JSC::CopiedBlock::shouldReportLiveBytes):
- (JSC::CopiedBlock::reportLiveBytes):
- * heap/CopiedSpace.h:
- (JSC::CopiedSpace::CopiedGeneration::CopiedGeneration):
- * heap/CopiedSpaceInlines.h:
- (JSC::CopiedSpace::recycleEvacuatedBlock):
- * heap/GCThreadSharedData.h:
- (JSC::GCThreadSharedData::getNextBlocksToCopy):
- * heap/ListableHandler.h:
- (JSC::ListableHandler::List::addThreadSafe):
- (JSC::ListableHandler::List::addNotThreadSafe):
- * heap/SlotVisitorInlines.h:
- (JSC::SlotVisitor::copyLater):
- * runtime/TypeProfilerLog.h:
-
2015-08-06 Sukolsak Sakshuwong <[email protected]>
Parse the entire WebAssembly modules
Modified: trunk/Source/_javascript_Core/dfg/DFGCommon.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/dfg/DFGCommon.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/dfg/DFGCommon.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -34,7 +34,7 @@
namespace JSC { namespace DFG {
-static StaticLock crashLock;
+static StaticSpinLock crashLock;
void startCrashing()
{
Modified: trunk/Source/_javascript_Core/heap/CopiedBlock.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/CopiedBlock.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/CopiedBlock.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -31,7 +31,7 @@
#include "Options.h"
#include <wtf/Atomics.h>
#include <wtf/DoublyLinkedList.h>
-#include <wtf/Lock.h>
+#include <wtf/SpinLock.h>
namespace JSC {
@@ -54,8 +54,8 @@
void didPromote();
unsigned liveBytes();
- bool shouldReportLiveBytes(LockHolder&, JSCell* owner);
- void reportLiveBytes(LockHolder&, JSCell*, CopyToken, unsigned);
+ bool shouldReportLiveBytes(SpinLockHolder&, JSCell* owner);
+ void reportLiveBytes(SpinLockHolder&, JSCell*, CopyToken, unsigned);
void reportLiveBytesDuringCopying(unsigned);
void didSurviveGC();
void didEvacuateBytes(unsigned);
@@ -85,7 +85,7 @@
bool hasWorkList();
CopyWorkList& workList();
- Lock& workListLock() { return m_workListLock; }
+ SpinLock& workListLock() { return m_workListLock; }
private:
CopiedBlock(size_t);
@@ -98,7 +98,7 @@
size_t m_capacity;
- Lock m_workListLock;
+ SpinLock m_workListLock;
std::unique_ptr<CopyWorkList> m_workList;
size_t m_remaining;
Modified: trunk/Source/_javascript_Core/heap/CopiedBlockInlines.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/CopiedBlockInlines.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/CopiedBlockInlines.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -33,7 +33,7 @@
namespace JSC {
-inline bool CopiedBlock::shouldReportLiveBytes(LockHolder&, JSCell* owner)
+inline bool CopiedBlock::shouldReportLiveBytes(SpinLockHolder&, JSCell* owner)
{
// We want to add to live bytes if the owner isn't part of the remembered set or
// if this block was allocated during the last cycle.
@@ -43,7 +43,7 @@
return !Heap::isRemembered(owner) || !m_isOld;
}
-inline void CopiedBlock::reportLiveBytes(LockHolder&, JSCell* owner, CopyToken token, unsigned bytes)
+inline void CopiedBlock::reportLiveBytes(SpinLockHolder&, JSCell* owner, CopyToken token, unsigned bytes)
{
checkConsistency();
#ifndef NDEBUG
Modified: trunk/Source/_javascript_Core/heap/CopiedSpace.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/CopiedSpace.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/CopiedSpace.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -191,7 +191,7 @@
{
// Always put the block into the old gen because it's being promoted!
- LockHolder locker(&m_toSpaceLock);
+ SpinLockHolder locker(&m_toSpaceLock);
m_oldGen.toSpace->push(block);
m_blockSet.add(block);
m_oldGen.blockFilter.add(reinterpret_cast<Bits>(block));
Modified: trunk/Source/_javascript_Core/heap/CopiedSpace.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/CopiedSpace.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/CopiedSpace.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -33,9 +33,9 @@
#include <wtf/CheckedBoolean.h>
#include <wtf/DoublyLinkedList.h>
#include <wtf/HashSet.h>
-#include <wtf/Lock.h>
#include <wtf/OSAllocator.h>
#include <wtf/PageBlock.h>
+#include <wtf/SpinLock.h>
#include <wtf/StdLibExtras.h>
#include <wtf/ThreadingPrimitives.h>
@@ -113,7 +113,7 @@
HashSet<CopiedBlock*> m_blockSet;
- Lock m_toSpaceLock;
+ SpinLock m_toSpaceLock;
struct CopiedGeneration {
CopiedGeneration()
Modified: trunk/Source/_javascript_Core/heap/CopiedSpaceInlines.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/CopiedSpaceInlines.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/CopiedSpaceInlines.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -98,7 +98,7 @@
ASSERT(block->canBeRecycled());
ASSERT(!block->m_isPinned);
{
- LockHolder locker(&m_toSpaceLock);
+ SpinLockHolder locker(&m_toSpaceLock);
m_blockSet.remove(block);
if (collectionType == EdenCollection)
m_newGen.fromSpace->remove(block);
Modified: trunk/Source/_javascript_Core/heap/GCThreadSharedData.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/GCThreadSharedData.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/GCThreadSharedData.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -178,7 +178,7 @@
void GCThreadSharedData::didStartCopying()
{
{
- LockHolder locker(&m_copyLock);
+ SpinLockHolder locker(&m_copyLock);
if (m_vm->heap.operationInProgress() == EdenCollection) {
// Reset the vector to be empty, but don't throw away the backing store.
m_blocksToCopy.shrink(0);
Modified: trunk/Source/_javascript_Core/heap/GCThreadSharedData.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/GCThreadSharedData.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/GCThreadSharedData.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -33,7 +33,7 @@
#include "WeakReferenceHarvester.h"
#include <condition_variable>
#include <wtf/HashSet.h>
-#include <wtf/Lock.h>
+#include <wtf/SpinLock.h>
#include <wtf/Vector.h>
namespace JSC {
@@ -97,7 +97,7 @@
std::mutex m_opaqueRootsMutex;
HashSet<void*> m_opaqueRoots;
- Lock m_copyLock;
+ SpinLock m_copyLock;
Vector<CopiedBlock*> m_blocksToCopy;
size_t m_copyIndex;
static const size_t s_blockFragmentLength = 32;
@@ -115,7 +115,7 @@
inline void GCThreadSharedData::getNextBlocksToCopy(size_t& start, size_t& end)
{
- LockHolder locker(&m_copyLock);
+ SpinLockHolder locker(&m_copyLock);
start = m_copyIndex;
end = std::min(m_blocksToCopy.size(), m_copyIndex + s_blockFragmentLength);
m_copyIndex = end;
Modified: trunk/Source/_javascript_Core/heap/ListableHandler.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/ListableHandler.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/ListableHandler.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -21,9 +21,9 @@
#define ListableHandler_h
#include <stdint.h>
-#include <wtf/Lock.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
+#include <wtf/SpinLock.h>
#include <wtf/ThreadingPrimitives.h>
namespace JSC {
@@ -65,7 +65,7 @@
void addThreadSafe(T* handler)
{
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
addNotThreadSafe(handler);
}
@@ -103,7 +103,7 @@
m_first = handler;
}
- Lock m_lock;
+ SpinLock m_lock;
T* m_first;
};
Modified: trunk/Source/_javascript_Core/heap/MachineStackMarker.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/MachineStackMarker.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/MachineStackMarker.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -568,8 +568,8 @@
{
// Prevent two VMs from suspending each other's threads at the same time,
// which can cause deadlock: <rdar://problem/20300842>.
- static StaticLock mutex;
- std::lock_guard<StaticLock> lock(mutex);
+ static StaticSpinLock mutex;
+ std::lock_guard<StaticSpinLock> lock(mutex);
*size = 0;
Modified: trunk/Source/_javascript_Core/heap/SlotVisitorInlines.h (188143 => 188144)
--- trunk/Source/_javascript_Core/heap/SlotVisitorInlines.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/heap/SlotVisitorInlines.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -250,7 +250,7 @@
ASSERT(heap()->m_storageSpace.contains(block));
- LockHolder locker(&block->workListLock());
+ SpinLockHolder locker(&block->workListLock());
if (heap()->operationInProgress() == FullCollection || block->shouldReportLiveBytes(locker, owner)) {
m_bytesCopied += bytes;
block->reportLiveBytes(locker, owner, token, bytes);
Modified: trunk/Source/_javascript_Core/parser/SourceProvider.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/parser/SourceProvider.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/parser/SourceProvider.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -27,7 +27,7 @@
#include "SourceProvider.h"
#include "JSCInlines.h"
-#include <wtf/Lock.h>
+#include <wtf/SpinLock.h>
#include <wtf/StdLibExtras.h>
namespace JSC {
@@ -44,11 +44,11 @@
{
}
-static StaticLock providerIdLock;
+static StaticSpinLock providerIdLock;
void SourceProvider::getID()
{
- LockHolder lock(&providerIdLock);
+ SpinLockHolder lock(&providerIdLock);
if (!m_id) {
static intptr_t nextProviderID = 0;
m_id = ++nextProviderID;
Modified: trunk/Source/_javascript_Core/profiler/ProfilerDatabase.cpp (188143 => 188144)
--- trunk/Source/_javascript_Core/profiler/ProfilerDatabase.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/profiler/ProfilerDatabase.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -35,7 +35,7 @@
static std::atomic<int> databaseCounter;
-static StaticLock registrationLock;
+static StaticSpinLock registrationLock;
static std::atomic<int> didRegisterAtExit;
static Database* firstDatabase;
@@ -138,14 +138,14 @@
if (++didRegisterAtExit == 1)
atexit(atExitCallback);
- LockHolder holder(registrationLock);
+ SpinLockHolder holder(registrationLock);
m_nextRegisteredDatabase = firstDatabase;
firstDatabase = this;
}
void Database::removeDatabaseFromAtExit()
{
- LockHolder holder(registrationLock);
+ SpinLockHolder holder(registrationLock);
for (Database** current = &firstDatabase; *current; current = &(*current)->m_nextRegisteredDatabase) {
if (*current != this)
continue;
@@ -163,7 +163,7 @@
Database* Database::removeFirstAtExitDatabase()
{
- LockHolder holder(registrationLock);
+ SpinLockHolder holder(registrationLock);
Database* result = firstDatabase;
if (result) {
firstDatabase = result->m_nextRegisteredDatabase;
Modified: trunk/Source/_javascript_Core/runtime/TypeProfilerLog.h (188143 => 188144)
--- trunk/Source/_javascript_Core/runtime/TypeProfilerLog.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/_javascript_Core/runtime/TypeProfilerLog.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -32,6 +32,7 @@
#include "JSCJSValue.h"
#include "Structure.h"
#include "TypeProfiler.h"
+#include <wtf/ByteSpinLock.h>
namespace JSC {
Modified: trunk/Source/WTF/ChangeLog (188143 => 188144)
--- trunk/Source/WTF/ChangeLog 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/ChangeLog 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,107 +1,5 @@
-2015-08-06 Filip Pizlo <[email protected]>
-
- Unreviewed, work around assertions in Windows's std::atomic.
-
- * wtf/Atomics.h:
- (WTF::Atomic::compareExchangeWeak):
- (WTF::Atomic::compareExchangeStrong):
-
2015-08-05 Filip Pizlo <[email protected]>
- Lightweight locks should be adaptive
- https://bugs.webkit.org/show_bug.cgi?id=147545
-
- Reviewed by Geoffrey Garen.
-
- A common idiom in WebKit is to use spinlocks. We use them because the lock acquisition
- overhead is lower than system locks and because they take dramatically less space than system
- locks. The speed and space advantages of spinlocks can be astonishing: an uncontended spinlock
- acquire is up to 10x faster and under microcontention - short critical section with two or
- more threads taking turns - spinlocks are up to 100x faster. Spinlocks take only 1 byte or 4
- bytes depending on the flavor, while system locks take 64 bytes or more. Clearly, WebKit
- should continue to avoid system locks - they are just far too slow and far too big.
-
- But there is a problem with this idiom. System lock implementations will sleep a thread when
- it attempts to acquire a lock that is held, while spinlocks will cause the thread to burn CPU.
- In WebKit spinlocks, the thread will repeatedly call sched_yield(). This is awesome for
- microcontention, but awful when the lock will not be released for a while. In fact, when
- critical sections take tens of microseconds or more, the CPU time cost of our spinlocks is
- almost 100x more than the CPU time cost of a system lock. This case doesn't arise too
- frequently in our current uses of spinlocks, but that's probably because right now there are
- places where we make a conscious decision to use system locks - even though they use more
- memory and are slower - because we don't want to waste CPU cycles when a thread has to wait a
- while to acquire the lock.
-
- The solution is to just implement a modern adaptive mutex in WTF. Luckily, this isn't a new
- concept. This patch implements a mutex that is reminiscent of the kinds of low-overhead locks
- that JVMs use. The actual implementation here is inspired by some of the ideas from [1]. The
- idea is simple: the fast path is an inlined CAS to immediately acquire a lock that isn't held,
- the slow path tries some number of spins to acquire the lock, and if that fails, the thread is
- put on a queue and put to sleep. The queue is made up of statically allocated thread nodes and
- the lock itself is a tagged pointer: either it is just bits telling us the complete lock state
- (not held or held) or it is a pointer to the head of a queue of threads waiting to acquire the
- lock. This approach gives WTF::Lock three different levels of adaptation: an inlined fast path
- if the lock is not contended, a short burst of spinning for microcontention, and a full-blown
- queue for critical sections that are held for a long time.
-
- On a locking microbenchmark, this new Lock exhibits the following performance
- characteristics:
-
- - Lock+unlock on an uncontended no-op critical section: 2x slower than SpinLock and 3x faster
- than a system mutex.
-
- - Lock+unlock on a contended no-op critical section: 2x slower than SpinLock and 100x faster
- than a system mutex.
-
- - CPU time spent in lock() on a lock held for a while: same as system mutex, 90x less than a
- SpinLock.
-
- - Memory usage: sizeof(void*), so on 64-bit it's 8x less than a system mutex but 2x worse than
- a SpinLock.
-
- This patch replaces all uses of SpinLock with Lock, since our critical sections are not
- no-ops so if you do basically anything in your critical section, the Lock overhead will be
- invisible. Also, in all places where we used SpinLock, we could tolerate 8 bytes of overhead
- instead of 4. Performance benchmarking using JSC macrobenchmarks shows no difference, which is
- as it should be: the purpose of this change is to reduce CPU time wasted, not wallclock time.
- This patch doesn't replace any uses of ByteSpinLock, since we expect that the space benefits
- of having a lock that just uses a byte are still better than the CPU wastage benefits of
- Lock. But, this work will enable some future work to create locks that will fit in just 1.6
- bits: https://bugs.webkit.org/show_bug.cgi?id=147665.
-
- [1] http://www.filpizlo.com/papers/pizlo-pppj2011-fable.pdf
-
- * WTF.vcxproj/WTF.vcxproj:
- * WTF.xcodeproj/project.pbxproj:
- * benchmarks: Added.
- * benchmarks/LockSpeedTest.cpp: Added.
- (main):
- * wtf/CMakeLists.txt:
- * wtf/Lock.cpp: Added.
- (WTF::LockBase::lockSlow):
- (WTF::LockBase::unlockSlow):
- * wtf/Lock.h: Added.
- (WTF::LockBase::lock):
- (WTF::LockBase::unlock):
- (WTF::LockBase::isHeld):
- (WTF::Lock::Lock):
- * wtf/MetaAllocator.cpp:
- (WTF::MetaAllocator::release):
- (WTF::MetaAllocatorHandle::shrink):
- (WTF::MetaAllocator::allocate):
- (WTF::MetaAllocator::currentStatistics):
- (WTF::MetaAllocator::addFreshFreeSpace):
- (WTF::MetaAllocator::debugFreeSpaceSize):
- * wtf/MetaAllocator.h:
- * wtf/SpinLock.h:
- * wtf/ThreadingPthreads.cpp:
- * wtf/ThreadingWin.cpp:
- * wtf/text/AtomicString.cpp:
- * wtf/text/AtomicStringImpl.cpp:
- (WTF::AtomicStringTableLocker::AtomicStringTableLocker):
-
-2015-08-05 Filip Pizlo <[email protected]>
-
Unreviewed, roll out http://trac.webkit.org/changeset/187972.
* wtf/Atomics.cpp:
Modified: trunk/Source/WTF/WTF.vcxproj/WTF.vcxproj (188143 => 188144)
--- trunk/Source/WTF/WTF.vcxproj/WTF.vcxproj 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/WTF.vcxproj/WTF.vcxproj 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="DebugSuffix|Win32">
@@ -106,7 +106,6 @@
<ClCompile Include="..\wtf\glib\GThreadSafeMainLoopSource.cpp" />
<ClCompile Include="..\wtf\GregorianDateTime.cpp" />
<ClCompile Include="..\wtf\HashTable.cpp" />
- <ClCompile Include="..\wtf\Lock.cpp" />
<ClCompile Include="..\wtf\MainThread.cpp" />
<ClCompile Include="..\wtf\MD5.cpp" />
<ClCompile Include="..\wtf\MediaTime.cpp" />
@@ -224,7 +223,6 @@
<ClInclude Include="..\wtf\IteratorAdaptors.h" />
<ClInclude Include="..\wtf\IteratorRange.h" />
<ClInclude Include="..\wtf\ListHashSet.h" />
- <ClInclude Include="..\wtf\Lock.h" />
<ClInclude Include="..\wtf\Locker.h" />
<ClInclude Include="..\wtf\MainThread.h" />
<ClInclude Include="..\wtf\MallocPtr.h" />
Modified: trunk/Source/WTF/WTF.xcodeproj/project.pbxproj (188143 => 188144)
--- trunk/Source/WTF/WTF.xcodeproj/project.pbxproj 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/WTF.xcodeproj/project.pbxproj 2015-08-07 18:51:00 UTC (rev 188144)
@@ -40,8 +40,6 @@
0FD81AC5154FB22E00983E72 /* FastBitVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FD81AC4154FB22E00983E72 /* FastBitVector.h */; settings = {ATTRIBUTES = (); }; };
0FDDBFA71666DFA300C55FEF /* StringPrintStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FDDBFA51666DFA300C55FEF /* StringPrintStream.cpp */; };
0FDDBFA81666DFA300C55FEF /* StringPrintStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDDBFA61666DFA300C55FEF /* StringPrintStream.h */; };
- 0FE1646A1B6FFC9600400E7C /* Lock.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FE164681B6FFC9600400E7C /* Lock.cpp */; };
- 0FE1646B1B6FFC9600400E7C /* Lock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FE164691B6FFC9600400E7C /* Lock.h */; };
0FED67B61B22D4D80066CE15 /* TinyPtrSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FED67B51B22D4D80066CE15 /* TinyPtrSet.h */; };
14022F4118F5C3FC007FF0EB /* libbmalloc.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 14022F4018F5C3FC007FF0EB /* libbmalloc.a */; };
143F611F1565F0F900DB514A /* RAMSize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 143F611D1565F0F900DB514A /* RAMSize.cpp */; };
@@ -323,8 +321,6 @@
0FD81AC4154FB22E00983E72 /* FastBitVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FastBitVector.h; sourceTree = "<group>"; };
0FDDBFA51666DFA300C55FEF /* StringPrintStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringPrintStream.cpp; sourceTree = "<group>"; };
0FDDBFA61666DFA300C55FEF /* StringPrintStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringPrintStream.h; sourceTree = "<group>"; };
- 0FE164681B6FFC9600400E7C /* Lock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Lock.cpp; sourceTree = "<group>"; };
- 0FE164691B6FFC9600400E7C /* Lock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Lock.h; sourceTree = "<group>"; };
0FEC3EE4171B834700FDAC8D /* ByteSpinLock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ByteSpinLock.h; sourceTree = "<group>"; };
0FED67B51B22D4D80066CE15 /* TinyPtrSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TinyPtrSet.h; sourceTree = "<group>"; };
14022F4018F5C3FC007FF0EB /* libbmalloc.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libbmalloc.a; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -774,8 +770,6 @@
7CDD7FF9186D2A54007433CD /* IteratorRange.h */,
A70DA0831799F04D00529A9B /* ListDump.h */,
A8A472C1151A825A004123FF /* ListHashSet.h */,
- 0FE164681B6FFC9600400E7C /* Lock.cpp */,
- 0FE164691B6FFC9600400E7C /* Lock.h */,
A8A472C3151A825A004123FF /* Locker.h */,
1447AEC818FCE59400B3D7FF /* mbmalloc.cpp */,
A8A472CA151A825B004123FF /* MD5.cpp */,
@@ -1212,7 +1206,6 @@
A8A4746A151A825B004123FF /* UTF8.h in Headers */,
A8A473B9151A825B004123FF /* utils.h in Headers */,
A8A4747D151A825B004123FF /* ValueCheck.h in Headers */,
- 0FE1646B1B6FFC9600400E7C /* Lock.h in Headers */,
A8A4747E151A825B004123FF /* Vector.h in Headers */,
A8A4747F151A825B004123FF /* VectorTraits.h in Headers */,
0FED67B61B22D4D80066CE15 /* TinyPtrSet.h in Headers */,
@@ -1344,7 +1337,6 @@
A8A4739E151A825B004123FF /* DataLog.cpp in Sources */,
A8A473A0151A825B004123FF /* DateMath.cpp in Sources */,
A8A473A2151A825B004123FF /* DecimalNumber.cpp in Sources */,
- 0FE1646A1B6FFC9600400E7C /* Lock.cpp in Sources */,
A8A473AE151A825B004123FF /* diy-fp.cc in Sources */,
A8A473B0151A825B004123FF /* double-conversion.cc in Sources */,
A8A473BA151A825B004123FF /* dtoa.cpp in Sources */,
Modified: trunk/Source/WTF/wtf/Atomics.h (188143 => 188144)
--- trunk/Source/WTF/wtf/Atomics.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/Atomics.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -91,21 +91,12 @@
bool compareExchangeWeak(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
{
-#if OS(WINDOWS)
- // Windows makes strange assertions about the argument to compare_exchange_weak, and anyway,
- // Windows is X86 so seq_cst is cheap.
- order = std::memory_order_seq_cst;
-#endif
T expectedOrActual = expected;
return value.compare_exchange_weak(expectedOrActual, desired, order);
}
bool compareExchangeStrong(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
{
-#if OS(WINDOWS)
- // See above.
- order = std::memory_order_seq_cst;
-#endif
T expectedOrActual = expected;
return value.compare_exchange_strong(expectedOrActual, desired, order);
}
Modified: trunk/Source/WTF/wtf/CMakeLists.txt (188143 => 188144)
--- trunk/Source/WTF/wtf/CMakeLists.txt 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/CMakeLists.txt 2015-08-07 18:51:00 UTC (rev 188144)
@@ -41,7 +41,6 @@
IteratorAdaptors.h
IteratorRange.h
ListHashSet.h
- Lock.h
Locker.h
MD5.h
MainThread.h
@@ -157,7 +156,6 @@
FunctionDispatcher.cpp
GregorianDateTime.cpp
HashTable.cpp
- Lock.cpp
MD5.cpp
MainThread.cpp
MediaTime.cpp
Deleted: trunk/Source/WTF/wtf/Lock.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/Lock.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/Lock.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,253 +0,0 @@
-/*
- * Copyright (C) 2015 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "Lock.h"
-
-#include "ThreadSpecific.h"
-#include "ThreadingPrimitives.h"
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-
-namespace WTF {
-
-namespace {
-
-// This data structure serves three purposes:
-//
-// 1) A parking mechanism for threads that go to sleep. That involves just a system mutex and
-// condition variable.
-//
-// 2) A queue node for when a thread is on some Lock's queue.
-//
-// 3) The queue head. This is kind of funky. When a thread is the head of a queue, it also serves as
-// the basic queue bookkeeping data structure. When a thread is dequeued, the next thread in the
-// queue takes on the queue head duties.
-struct ThreadData {
- // The parking mechanism.
- bool shouldPark { false };
- std::mutex parkingLock;
- std::condition_variable parkingCondition;
-
- // The queue node.
- ThreadData* nextInQueue { nullptr };
-
- // The queue itself.
- ThreadData* queueTail { nullptr };
-};
-
-ThreadSpecific<ThreadData>* threadData;
-
-ThreadData* myThreadData()
-{
- static std::once_flag initializeOnce;
- std::call_once(
- initializeOnce,
- [] {
- threadData = new ThreadSpecific<ThreadData>();
- });
-
- return *threadData;
-}
-
-} // anonymous namespace
-
-void LockBase::lockSlow()
-{
- unsigned spinCount = 0;
-
- // This magic number turns out to be optimal based on past JikesRVM experiments.
- const unsigned spinLimit = 40;
-
- for (;;) {
- uintptr_t currentWordValue = m_word.load();
-
- if (!(currentWordValue & isLockedBit)) {
- // It's not possible for someone to hold the queue lock while the lock itself is no longer
- // held, since we will only attempt to acquire the queue lock when the lock is held and
- // the queue lock prevents unlock.
- ASSERT(!(currentWordValue & isQueueLockedBit));
- if (m_word.compareExchangeWeak(currentWordValue, currentWordValue | isLockedBit)) {
- // Success! We acquired the lock.
- return;
- }
- }
-
- // If there is no queue and we haven't spun too much, we can just try to spin around again.
- if (!(currentWordValue & ~queueHeadMask) && spinCount < spinLimit) {
- spinCount++;
- std::this_thread::yield();
- continue;
- }
-
- // Need to put ourselves on the queue. Create the queue if one does not exist. This requries
- // owning the queue for a little bit. The lock that controls the queue is itself a spinlock.
- // But before we acquire the queue spinlock, we make sure that we have a ThreadData for this
- // thread.
- ThreadData* me = myThreadData();
- ASSERT(!me->shouldPark);
- ASSERT(!me->nextInQueue);
- ASSERT(!me->queueTail);
-
- // Reload the current word value, since some time may have passed.
- currentWordValue = m_word.load();
-
- // We proceed only if the queue lock is not held, the Lock is held, and we succeed in
- // acquiring the queue lock.
- if ((currentWordValue & isQueueLockedBit)
- || !(currentWordValue & isLockedBit)
- || !m_word.compareExchangeWeak(currentWordValue, currentWordValue | isQueueLockedBit)) {
- std::this_thread::yield();
- continue;
- }
-
- me->shouldPark = true;
-
- // We own the queue. Nobody can enqueue or dequeue until we're done. Also, it's not possible
- // to release the Lock while we hold the queue lock.
- ThreadData* queueHead = bitwise_cast<ThreadData*>(currentWordValue & ~queueHeadMask);
- if (queueHead) {
- // Put this thread at the end of the queue.
- queueHead->queueTail->nextInQueue = me;
- queueHead->queueTail = me;
-
- // Release the queue lock.
- currentWordValue = m_word.load();
- ASSERT(currentWordValue & ~queueHeadMask);
- ASSERT(currentWordValue & isQueueLockedBit);
- ASSERT(currentWordValue & isLockedBit);
- m_word.store(currentWordValue & ~isQueueLockedBit);
- } else {
- // Make this thread be the queue-head.
- queueHead = me;
- me->queueTail = me;
-
- // Release the queue lock and install ourselves as the head. No need for a CAS loop, since
- // we own the queue lock.
- currentWordValue = m_word.load();
- ASSERT(~(currentWordValue & ~queueHeadMask));
- ASSERT(currentWordValue & isQueueLockedBit);
- ASSERT(currentWordValue & isLockedBit);
- uintptr_t newWordValue = currentWordValue;
- newWordValue |= bitwise_cast<uintptr_t>(queueHead);
- newWordValue &= ~isQueueLockedBit;
- m_word.store(newWordValue);
- }
-
- // At this point everyone who acquires the queue lock will see me on the queue, and anyone who
- // acquires me's lock will see that me wants to park. Note that shouldPark may have been
- // cleared as soon as the queue lock was released above, but it will happen while the
- // releasing thread holds me's parkingLock.
-
- {
- std::unique_lock<std::mutex> locker(me->parkingLock);
- while (me->shouldPark)
- me->parkingCondition.wait(locker);
- }
-
- ASSERT(!me->shouldPark);
- ASSERT(!me->nextInQueue);
- ASSERT(!me->queueTail);
-
- // Now we can loop around and try to acquire the lock again.
- }
-}
-
-void LockBase::unlockSlow()
-{
- // If the fast path failed, it can only be because someone put a thread on the queue or the queue
- // lock is held. If the queue lock is held, it can only be because someone *will* enqueue a thread
- // onto the queue.
-
- // Acquire the queue lock.
- for (;;) {
- uintptr_t currentWordValue = m_word.load();
-
- ASSERT(currentWordValue & isLockedBit);
-
- if (currentWordValue & isQueueLockedBit) {
- std::this_thread::yield();
- continue;
- }
-
- // If the queue lock is not held, then there must be an entry on the queue.
- ASSERT(currentWordValue & ~queueHeadMask);
-
- if (m_word.compareExchangeWeak(currentWordValue, currentWordValue | isQueueLockedBit))
- break;
- }
-
- uintptr_t currentWordValue = m_word.load();
-
- // After we acquire the queue lock, the Lock must still be held and the queue must be
- // non-empty. The queue must be non-empty since only the lockSlow() method could have held the
- // queue lock and if it did then it only releases it after putting something on the queue.
- ASSERT(currentWordValue & isLockedBit);
- ASSERT(currentWordValue & isQueueLockedBit);
- ThreadData* queueHead = bitwise_cast<ThreadData*>(currentWordValue & ~queueHeadMask);
- ASSERT(queueHead);
-
- ThreadData* newQueueHead = queueHead->nextInQueue;
- // Either this was the only thread on the queue, in which case we delete the queue, or there
- // are still more threads on the queue, in which case we create a new queue head.
- if (newQueueHead)
- newQueueHead->queueTail = queueHead->queueTail;
-
- // Change the queue head, possibly removing it if newQueueHead is null. No need for a CAS loop,
- // since we hold the queue lock and the lock itself so nothing about the lock can change right
- // now.
- currentWordValue = m_word.load();
- ASSERT(currentWordValue & isLockedBit);
- ASSERT(currentWordValue & isQueueLockedBit);
- ASSERT((currentWordValue & ~queueHeadMask) == bitwise_cast<uintptr_t>(queueHead));
- uintptr_t newWordValue = currentWordValue;
- newWordValue &= ~isLockedBit; // Release the Lock.
- newWordValue &= ~isQueueLockedBit; // Release the queue lock.
- newWordValue &= queueHeadMask; // Clear out the old queue head.
- newWordValue |= bitwise_cast<uintptr_t>(newQueueHead); // Install new queue head.
- m_word.store(newWordValue);
-
- // Now the lock is available for acquisition. But we just have to wake up the old queue head.
- // After that, we're done!
-
- queueHead->nextInQueue = nullptr;
- queueHead->queueTail = nullptr;
-
- // We do this carefully because this may run either before or during the parkingLock critical
- // section in lockSlow().
- {
- std::unique_lock<std::mutex> locker(queueHead->parkingLock);
- queueHead->shouldPark = false;
- }
- // Doesn't matter if we notify_all() or notify_one() here since the only thread that could be
- // waiting is queueHead.
- queueHead->parkingCondition.notify_one();
-
- // The old queue head can now contend for the lock again. We're done!
-}
-
-} // namespace WTF
-
Deleted: trunk/Source/WTF/wtf/Lock.h (188143 => 188144)
--- trunk/Source/WTF/wtf/Lock.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/Lock.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2015 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef WTF_Lock_h
-#define WTF_Lock_h
-
-#include <wtf/Atomics.h>
-#include <wtf/Compiler.h>
-#include <wtf/Locker.h>
-#include <wtf/Noncopyable.h>
-
-namespace WTF {
-
-// A Lock is a fully adaptive mutex that gives you the best of SpinLock and Mutex. For small critical
-// sections (that take nanoseconds), it will usually perform within 2x of a SpinLock in both the
-// contended and uncontended case. When using a Mutex, such critical sections take up to 100x longer
-// than Lock in the contended case, or 3x longer than Lock in the uncontended case. For longer
-// critical sections (that take tens of microseconds), it will perform as well as a Mutex and slightly
-// better than a SpinLock. But, crucially, a SpinLock will burn up to 90x more time in the kernel for
-// such critical sections than either Lock or Mutex. Hence, using Lock will make the common case of
-// locking perform close to SpinLock for any critical section that does more than a few nanoseconds of
-// work while being as kind to the scheduler for longer critical sections as a Mutex.
-//
-// Like SpinLock, Lock takes very little memory - just sizeof(void*), though see a detailed caveat
-// below.
-//
-// Generally, you should use Lock instead of SpinLock because while it penalizes you slightly, you
-// make up for it by not wasting CPU cycles in case of contention.
-//
-// The Lock has the following nice properties:
-//
-// - Uncontended fast paths for lock acquisition and lock release that are almost as fast as the
-// uncontended fast paths of a spinlock. The only overhead is that the spinlock will not CAS on
-// release, while Lock will CAS. This overhead *can* slow things down for extremely small critical
-// sections that do little or nothing - it makes them 2x slower since in that case, CAS is the most
-// expensive instruction and having two of them is twice as bad as just having one. However, this
-// lock implementation is still almost 3x faster than a platform mutex in those cases. It's unlikely
-// that you'll encounter no-op critical sections, so usually, this lock is better than a spinlock.
-//
-// - Contended fast path that attempts to spin and yield for some number of times. For critical
-// sections that are held only briefly, this allows Lock to perform almost as well as a SpinLock.
-// SpinLock can still be almost 2x faster than Lock if the critical section is a no-op, but this
-// advantage diminishes as the critical section grows.
-//
-// - Contended slow path that enqueues the contending thread and causes it to wait on a condition
-// variable until the lock is released. This is the only case in which system mutexes and condition
-// variables are used. This case is rare and self-limiting: it will only happen when a lock is held
-// for long enough that spinning some number of times doesn't acquire it. The fact that Lock does
-// this as a fallback when spinning for some number of times fails means that it will burn
-// dramatically fewer CPU cycles - for example with 10 threads on an 8 logical CPU machine acquiring
-// a critical section that takes 50 microseconds, the WTF SpinLock will cause 90x more time to be
-// spent in the kernel than Lock.
-//
-// - Very low memory usage. Each Lock requires only sizeof(void*) memory. When the contended slow
-// path is activated, Lock only relies on each thread having a preallocated thread-specific data
-// structure called ThreadData that, together with the Lock itself, is used to build up a thread
-// queue. So, the total memory usage of all Locks is still bounded by:
-//
-// numberOfLocks * sizeof(void*) + numberOfThreads * sizeof(ThreadData)
-//
-// Where ThreadData is a decently large data structure, but we will only ever have one per thread,
-// regardless of the number of Locks in memory. Another way to view this is that the worst case
-// memory usage per Lock is:
-//
-// sizeof(void*) + numberOfThreads / numberOfLocks * sizeof(ThreadData)
-//
-// So, unless you have a small number of Locks (or, a large number of threads, which is far less
-// likely), the memory usage per-Lock is still going to be somewhere around sizeof(void*).
-//
-// - Barging fast paths. The Lock is tuned for maximum throughput rather than maximum fairness. If
-// a thread releases a Lock that was contended and had a queue of waiting threads, then it will
-// wake up the head of the queue, but it will also mark the lock as being available. This means that
-// some other thread that is just now attempting to acquire the lock may get it before the thread
-// that got woken up. When a thread barges into the lock, the thread that got woken up will simply
-// go back to the end of the queue. The barging behavior ends up being probabilistic on most
-// platforms and even though it may be unfair to some thread at some moment in time, it will rarely
-// have a long streak of unfairness towards any particular thread: eventually each thread waiting on
-// the lock will get to have a turn so long as no thread just holds the lock forever. That said,
-// there *is* a chance of pathologies - users of Lock should not depend on first-in, first-out lock
-// acquisition order under contention. The same caveat is generally true of SpinLock and platform
-// mutexes on some platforms.
-
-// This is a struct without a constructor or destructor so that it can be statically initialized.
-// Use Lock in instance variables.
-struct LockBase {
- void lock()
- {
- if (LIKELY(m_word.compareExchangeWeak(0, isLockedBit, std::memory_order_acquire))) {
- // Lock acquired!
- return;
- }
-
- lockSlow();
- }
-
- void unlock()
- {
- if (LIKELY(m_word.compareExchangeWeak(isLockedBit, 0, std::memory_order_release))) {
- // Lock released, and nobody was waiting!
- return;
- }
-
- unlockSlow();
- }
-
- bool isHeld() const
- {
- return m_word.load(std::memory_order_acquire) & isLockedBit;
- }
-
- bool isLocked() const
- {
- return isHeld();
- }
-
-protected:
- static const uintptr_t isLockedBit = 1;
- static const uintptr_t isQueueLockedBit = 2;
- static const uintptr_t queueHeadMask = 3;
-
- WTF_EXPORT_PRIVATE void lockSlow();
- WTF_EXPORT_PRIVATE void unlockSlow();
-
- Atomic<uintptr_t> m_word;
-};
-
-class Lock : public LockBase {
- WTF_MAKE_NONCOPYABLE(Lock);
-public:
- Lock()
- {
- m_word.store(0, std::memory_order_relaxed);
- }
-};
-
-typedef LockBase StaticLock;
-typedef Locker<LockBase> LockHolder;
-
-} // namespace WTF
-
-using WTF::StaticLock;
-using WTF::Lock;
-using WTF::LockHolder;
-
-#endif // WTF_Lock_h
-
Modified: trunk/Source/WTF/wtf/MetaAllocator.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/MetaAllocator.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/MetaAllocator.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -60,7 +60,7 @@
ALWAYS_INLINE void MetaAllocator::release(MetaAllocatorHandle* handle)
{
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
if (handle->sizeInBytes()) {
decrementPageOccupancy(handle->start(), handle->sizeInBytes());
addFreeSpaceFromReleasedHandle(handle->start(), handle->sizeInBytes());
@@ -91,7 +91,7 @@
{
ASSERT(newSizeInBytes <= m_sizeInBytes);
- LockHolder locker(&m_allocator->m_lock);
+ SpinLockHolder locker(&m_allocator->m_lock);
newSizeInBytes = m_allocator->roundUp(newSizeInBytes);
@@ -150,7 +150,7 @@
PassRefPtr<MetaAllocatorHandle> MetaAllocator::allocate(size_t sizeInBytes, void* ownerUID)
{
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
if (!sizeInBytes)
return 0;
@@ -196,7 +196,7 @@
MetaAllocator::Statistics MetaAllocator::currentStatistics()
{
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
Statistics result;
result.bytesAllocated = m_bytesAllocated;
result.bytesReserved = m_bytesReserved;
@@ -281,7 +281,7 @@
void MetaAllocator::addFreshFreeSpace(void* start, size_t sizeInBytes)
{
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
m_bytesReserved += sizeInBytes;
addFreeSpace(start, sizeInBytes);
}
@@ -289,7 +289,7 @@
size_t MetaAllocator::debugFreeSpaceSize()
{
#ifndef NDEBUG
- LockHolder locker(&m_lock);
+ SpinLockHolder locker(&m_lock);
size_t result = 0;
for (FreeSpaceNode* node = m_freeSpaceSizeMap.first(); node; node = node->successor())
result += node->m_sizeInBytes;
Modified: trunk/Source/WTF/wtf/MetaAllocator.h (188143 => 188144)
--- trunk/Source/WTF/wtf/MetaAllocator.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/MetaAllocator.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -31,13 +31,13 @@
#include <wtf/Assertions.h>
#include <wtf/HashMap.h>
-#include <wtf/Lock.h>
#include <wtf/MetaAllocatorHandle.h>
#include <wtf/Noncopyable.h>
#include <wtf/PageBlock.h>
#include <wtf/RedBlackTree.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
+#include <wtf/SpinLock.h>
namespace WTF {
@@ -183,7 +183,7 @@
size_t m_bytesReserved;
size_t m_bytesCommitted;
- Lock m_lock;
+ SpinLock m_lock;
MetaAllocatorTracker* m_tracker;
Modified: trunk/Source/WTF/wtf/SpinLock.h (188143 => 188144)
--- trunk/Source/WTF/wtf/SpinLock.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/SpinLock.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -32,16 +32,6 @@
namespace WTF {
-// SpinLock is a very simple lock implementation that has extremely fast lock/unlock for very small
-// uncontended critical sections. However, it will exhibit bad performance degradation when the lock
-// becomes contended: the thread trying to acquire the lock will simply waste CPU cycles.
-//
-// For most (all?) locking use cases, it's better to use Lock (see wtf/Lock.h). That uses only a bit
-// more memory (8 bytes instead of 4 on 64-bit), and is only a bit slower in the uncontended case
-// (Lock needs CAS to unlock, while SpinLock doesn't), but will burn a lot less CPU time - for 10
-// threads acquiring a 50 microsecond critical section, Lock will use up to 100x less kernel CPU time
-// than SpinLock.
-
// SpinLockBase is a struct without an explicitly defined constructors so that
// it can be initialized at compile time. See StaticSpinLock below.
struct SpinLockBase {
Modified: trunk/Source/WTF/wtf/ThreadingPthreads.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/ThreadingPthreads.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/ThreadingPthreads.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2007, 2009, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
* Copyright (C) 2007 Justin Haygood ([email protected])
* Copyright (C) 2011 Research In Motion Limited. All rights reserved.
*
Modified: trunk/Source/WTF/wtf/ThreadingWin.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/ThreadingWin.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/ThreadingWin.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2007, 2008, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
* Copyright (C) 2009 Google Inc. All rights reserved.
* Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
*
Modified: trunk/Source/WTF/wtf/text/AtomicString.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/text/AtomicString.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/text/AtomicString.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -27,7 +27,7 @@
#include "dtoa.h"
#if USE(WEB_THREAD)
-#include "Lock.h"
+#include "SpinLock.h"
#endif
namespace WTF {
Modified: trunk/Source/WTF/wtf/text/AtomicStringImpl.cpp (188143 => 188144)
--- trunk/Source/WTF/wtf/text/AtomicStringImpl.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WTF/wtf/text/AtomicStringImpl.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -33,7 +33,7 @@
#include <wtf/unicode/UTF8.h>
#if USE(WEB_THREAD)
-#include "Lock.h"
+#include "SpinLock.h"
#endif
namespace WTF {
@@ -42,18 +42,18 @@
#if USE(WEB_THREAD)
-class AtomicStringTableLocker : public LockHolder {
+class AtomicStringTableLocker : public SpinLockHolder {
WTF_MAKE_NONCOPYABLE(AtomicStringTableLocker);
- static StaticLock s_stringTableLock;
+ static StaticSpinLock s_stringTableLock;
public:
AtomicStringTableLocker()
- : LockHolder(&s_stringTableLock)
+ : SpinLockHolder(&s_stringTableLock)
{
}
};
-StaticLock AtomicStringTableLocker::s_stringTableLock;
+StaticSpinLock AtomicStringTableLocker::s_stringTableLock;
#else
Modified: trunk/Source/WebCore/ChangeLog (188143 => 188144)
--- trunk/Source/WebCore/ChangeLog 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebCore/ChangeLog 2015-08-07 18:51:00 UTC (rev 188144)
@@ -445,24 +445,6 @@
* CMakeLists.txt:
MockCDM is necessary for testing if ENCRYPTED_MEDIA_V2 is enabled.
-2015-08-05 Filip Pizlo <[email protected]>
-
- Lightweight locks should be adaptive
- https://bugs.webkit.org/show_bug.cgi?id=147545
-
- Reviewed by Geoffrey Garen.
-
- No new tests because no new behavior.
-
- * bindings/objc/WebScriptObject.mm:
- (WebCore::getJSWrapper):
- (WebCore::addJSWrapper):
- (WebCore::removeJSWrapper):
- (WebCore::removeJSWrapperIfRetainCountOne):
- * platform/ios/wak/WAKWindow.mm:
- (-[WAKWindow setExposedScrollViewRect:]):
- (-[WAKWindow exposedScrollViewRect]):
-
2015-08-06 Alex Christensen <[email protected]>
[Win] Enable all Windows features in CMake
Modified: trunk/Source/WebCore/bindings/objc/WebScriptObject.mm (188143 => 188144)
--- trunk/Source/WebCore/bindings/objc/WebScriptObject.mm 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebCore/bindings/objc/WebScriptObject.mm 2015-08-07 18:51:00 UTC (rev 188144)
@@ -48,7 +48,7 @@
#import <runtime/JSLock.h>
#import <runtime/Completion.h>
#import <runtime/Completion.h>
-#import <wtf/Lock.h>
+#import <wtf/SpinLock.h>
#import <wtf/Threading.h>
#import <wtf/spi/cocoa/NSMapTableSPI.h>
#import <wtf/text/WTFString.h>
@@ -72,12 +72,12 @@
namespace WebCore {
static NSMapTable* JSWrapperCache;
-static StaticLock spinLock;
+static StaticSpinLock spinLock;
NSObject* getJSWrapper(JSObject* impl)
{
ASSERT(isMainThread());
- LockHolder holder(&spinLock);
+ SpinLockHolder holder(&spinLock);
if (!JSWrapperCache)
return nil;
@@ -88,7 +88,7 @@
void addJSWrapper(NSObject* wrapper, JSObject* impl)
{
ASSERT(isMainThread());
- LockHolder holder(&spinLock);
+ SpinLockHolder holder(&spinLock);
if (!JSWrapperCache)
JSWrapperCache = createWrapperCache();
@@ -97,7 +97,7 @@
void removeJSWrapper(JSObject* impl)
{
- LockHolder holder(&spinLock);
+ SpinLockHolder holder(&spinLock);
if (!JSWrapperCache)
return;
@@ -106,7 +106,7 @@
static void removeJSWrapperIfRetainCountOne(NSObject* wrapper, JSObject* impl)
{
- LockHolder holder(&spinLock);
+ SpinLockHolder holder(&spinLock);
if (!JSWrapperCache)
return;
Modified: trunk/Source/WebCore/platform/audio/mac/CARingBuffer.cpp (188143 => 188144)
--- trunk/Source/WebCore/platform/audio/mac/CARingBuffer.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebCore/platform/audio/mac/CARingBuffer.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -200,7 +200,7 @@
void CARingBuffer::setCurrentFrameBounds(uint64_t startTime, uint64_t endTime)
{
- LockHolder locker(m_currentFrameBoundsLock);
+ ByteSpinLocker locker(m_currentFrameBoundsLock);
uint32_t nextPtr = m_timeBoundsQueuePtr + 1;
uint32_t index = nextPtr & kGeneralRingTimeBoundsQueueMask;
@@ -212,7 +212,7 @@
void CARingBuffer::getCurrentFrameBounds(uint64_t &startTime, uint64_t &endTime)
{
- LockHolder locker(m_currentFrameBoundsLock);
+ ByteSpinLocker locker(m_currentFrameBoundsLock);
uint32_t curPtr = m_timeBoundsQueuePtr;
uint32_t index = curPtr & kGeneralRingTimeBoundsQueueMask;
CARingBuffer::TimeBounds& bounds = m_timeBoundsQueue[index];
Modified: trunk/Source/WebCore/platform/audio/mac/CARingBuffer.h (188143 => 188144)
--- trunk/Source/WebCore/platform/audio/mac/CARingBuffer.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebCore/platform/audio/mac/CARingBuffer.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -29,7 +29,7 @@
#if ENABLE(WEB_AUDIO) && USE(MEDIATOOLBOX)
#include <runtime/ArrayBuffer.h>
-#include <wtf/Lock.h>
+#include <wtf/ByteSpinLock.h>
#include <wtf/Vector.h>
typedef struct AudioBufferList AudioBufferList;
@@ -84,7 +84,7 @@
};
Vector<TimeBounds> m_timeBoundsQueue;
- Lock m_currentFrameBoundsLock;
+ ByteSpinLock m_currentFrameBoundsLock;
int32_t m_timeBoundsQueuePtr;
};
Modified: trunk/Source/WebCore/platform/ios/wak/WAKWindow.mm (188143 => 188144)
--- trunk/Source/WebCore/platform/ios/wak/WAKWindow.mm 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebCore/platform/ios/wak/WAKWindow.mm 2015-08-07 18:51:00 UTC (rev 188144)
@@ -36,7 +36,7 @@
#import "WKContentObservation.h"
#import "WKViewPrivate.h"
#import <QuartzCore/QuartzCore.h>
-#import <wtf/Lock.h>
+#import <wtf/SpinLock.h>
WEBCORE_EXPORT NSString * const WAKWindowScreenScaleDidChangeNotification = @"WAKWindowScreenScaleDidChangeNotification";
WEBCORE_EXPORT NSString * const WAKWindowVisibilityDidChangeNotification = @"WAKWindowVisibilityDidChangeNotification";
@@ -56,7 +56,7 @@
static id<OrientationProvider> gOrientationProvider;
@implementation WAKWindow {
- Lock _exposedScrollViewRectLock;
+ SpinLock _exposedScrollViewRectLock;
CGRect _exposedScrollViewRect;
}
@@ -358,14 +358,14 @@
- (void)setExposedScrollViewRect:(CGRect)exposedScrollViewRect
{
- LockHolder locker(&_exposedScrollViewRectLock);
+ SpinLockHolder locker(&_exposedScrollViewRectLock);
_exposedScrollViewRect = exposedScrollViewRect;
}
- (CGRect)exposedScrollViewRect
{
{
- LockHolder locker(&_exposedScrollViewRectLock);
+ SpinLockHolder locker(&_exposedScrollViewRectLock);
if (!CGRectIsNull(_exposedScrollViewRect))
return _exposedScrollViewRect;
}
Modified: trunk/Source/WebKit2/ChangeLog (188143 => 188144)
--- trunk/Source/WebKit2/ChangeLog 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebKit2/ChangeLog 2015-08-07 18:51:00 UTC (rev 188144)
@@ -130,24 +130,6 @@
* UIProcess/ios/WKContentViewInteraction.mm:
(-[WKContentView _longPressRecognized:]):
-2015-08-05 Filip Pizlo <[email protected]>
-
- Lightweight locks should be adaptive
- https://bugs.webkit.org/show_bug.cgi?id=147545
-
- Reviewed by Geoffrey Garen.
-
- * WebProcess/WebPage/EventDispatcher.cpp:
- (WebKit::EventDispatcher::clearQueuedTouchEventsForPage):
- (WebKit::EventDispatcher::getQueuedTouchEventsForPage):
- (WebKit::EventDispatcher::touchEvent):
- (WebKit::EventDispatcher::dispatchTouchEvents):
- * WebProcess/WebPage/EventDispatcher.h:
- * WebProcess/WebPage/ViewUpdateDispatcher.cpp:
- (WebKit::ViewUpdateDispatcher::visibleContentRectUpdate):
- (WebKit::ViewUpdateDispatcher::dispatchVisibleContentRectUpdate):
- * WebProcess/WebPage/ViewUpdateDispatcher.h:
-
2015-08-06 Matt Rajca <[email protected]>
Media Session: notify focus manager clients when the playing state of the focused media element changes
Modified: trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp (188143 => 188144)
--- trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -172,13 +172,13 @@
#if ENABLE(IOS_TOUCH_EVENTS)
void EventDispatcher::clearQueuedTouchEventsForPage(const WebPage& webPage)
{
- LockHolder locker(&m_touchEventsLock);
+ SpinLockHolder locker(&m_touchEventsLock);
m_touchEvents.remove(webPage.pageID());
}
void EventDispatcher::getQueuedTouchEventsForPage(const WebPage& webPage, TouchEventQueue& destinationQueue)
{
- LockHolder locker(&m_touchEventsLock);
+ SpinLockHolder locker(&m_touchEventsLock);
destinationQueue = m_touchEvents.take(webPage.pageID());
}
@@ -186,7 +186,7 @@
{
bool updateListWasEmpty;
{
- LockHolder locker(&m_touchEventsLock);
+ SpinLockHolder locker(&m_touchEventsLock);
updateListWasEmpty = m_touchEvents.isEmpty();
auto addResult = m_touchEvents.add(pageID, TouchEventQueue());
if (addResult.isNewEntry)
@@ -217,7 +217,7 @@
{
HashMap<uint64_t, TouchEventQueue> localCopy;
{
- LockHolder locker(&m_touchEventsLock);
+ SpinLockHolder locker(&m_touchEventsLock);
localCopy.swap(m_touchEvents);
}
Modified: trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.h (188143 => 188144)
--- trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -32,9 +32,9 @@
#include <WebEvent.h>
#include <memory>
#include <wtf/HashMap.h>
-#include <wtf/Lock.h>
#include <wtf/Noncopyable.h>
#include <wtf/RefPtr.h>
+#include <wtf/SpinLock.h>
#include <wtf/ThreadingPrimitives.h>
namespace WebCore {
@@ -97,7 +97,7 @@
#endif
std::unique_ptr<WebCore::WheelEventDeltaTracker> m_recentWheelEventDeltaTracker;
#if ENABLE(IOS_TOUCH_EVENTS)
- Lock m_touchEventsLock;
+ SpinLock m_touchEventsLock;
HashMap<uint64_t, TouchEventQueue> m_touchEvents;
#endif
};
Modified: trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.cpp (188143 => 188144)
--- trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -58,7 +58,7 @@
{
bool updateListWasEmpty;
{
- LockHolder locker(&m_dataMutex);
+ SpinLockHolder locker(&m_dataMutex);
updateListWasEmpty = m_latestUpdate.isEmpty();
auto iterator = m_latestUpdate.find(pageID);
if (iterator == m_latestUpdate.end())
@@ -78,7 +78,7 @@
{
HashMap<uint64_t, UpdateData> update;
{
- LockHolder locker(&m_dataMutex);
+ SpinLockHolder locker(&m_dataMutex);
update = WTF::move(m_latestUpdate);
}
Modified: trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.h (188143 => 188144)
--- trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.h 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.h 2015-08-07 18:51:00 UTC (rev 188144)
@@ -30,8 +30,8 @@
#include "VisibleContentRectUpdateInfo.h"
#include <wtf/HashMap.h>
-#include <wtf/Lock.h>
#include <wtf/Ref.h>
+#include <wtf/SpinLock.h>
namespace WebKit {
@@ -57,7 +57,7 @@
};
Ref<WorkQueue> m_queue;
- Lock m_dataMutex;
+ SpinLock m_dataMutex;
HashMap<uint64_t, UpdateData> m_latestUpdate;
};
Modified: trunk/Tools/ChangeLog (188143 => 188144)
--- trunk/Tools/ChangeLog 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Tools/ChangeLog 2015-08-07 18:51:00 UTC (rev 188144)
@@ -83,13 +83,6 @@
* TestWebKitAPI/Tests/WebKit2Gtk/WebExtensionTest.cpp:
(methodCallCallback):
-2015-08-06 Filip Pizlo <[email protected]>
-
- Unreviewed, reduce the duration of a Lock unit test. It was timing out.
-
- * TestWebKitAPI/Tests/WTF/Lock.cpp:
- (TestWebKitAPI::TEST):
-
2015-08-06 Joseph Pecoraro <[email protected]>
Running tests for a long time results in some tests running very slowly (throttling)
@@ -103,20 +96,6 @@
COCOA ports default to having these setting enabled. Note, there is
still other timer throttling not covered by these setting.
-2015-08-06 Filip Pizlo <[email protected]>
-
- Lightweight locks should be adaptive
- https://bugs.webkit.org/show_bug.cgi?id=147545
-
- Reviewed by Geoffrey Garen.
-
- * TestWebKitAPI/CMakeLists.txt:
- * TestWebKitAPI/TestWebKitAPI.vcxproj/TestWebKitAPI.vcxproj:
- * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
- * TestWebKitAPI/Tests/WTF/Lock.cpp: Added.
- (TestWebKitAPI::runLockTest):
- (TestWebKitAPI::TEST):
-
2015-08-06 Ryosuke Niwa <[email protected]>
http_server_driver and benchmark_builder should not be in run-benchmark's plan files
Modified: trunk/Tools/TestWebKitAPI/CMakeLists.txt (188143 => 188144)
--- trunk/Tools/TestWebKitAPI/CMakeLists.txt 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Tools/TestWebKitAPI/CMakeLists.txt 2015-08-07 18:51:00 UTC (rev 188144)
@@ -75,7 +75,6 @@
${TESTWEBKITAPI_DIR}/Tests/WTF/HashSet.cpp
${TESTWEBKITAPI_DIR}/Tests/WTF/IntegerToStringConversion.cpp
${TESTWEBKITAPI_DIR}/Tests/WTF/ListHashSet.cpp
- ${TESTWEBKITAPI_DIR}/Tests/WTF/Lock.cpp
${TESTWEBKITAPI_DIR}/Tests/WTF/MD5.cpp
${TESTWEBKITAPI_DIR}/Tests/WTF/MathExtras.cpp
${TESTWEBKITAPI_DIR}/Tests/WTF/MediaTime.cpp
Modified: trunk/Tools/TestWebKitAPI/TestWebKitAPI.vcxproj/TestWebKitAPI.vcxproj (188143 => 188144)
--- trunk/Tools/TestWebKitAPI/TestWebKitAPI.vcxproj/TestWebKitAPI.vcxproj 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Tools/TestWebKitAPI/TestWebKitAPI.vcxproj/TestWebKitAPI.vcxproj 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="DebugSuffix|Win32">
@@ -319,7 +319,6 @@
<ClCompile Include="..\Tests\WTF\HashSet.cpp" />
<ClCompile Include="..\Tests\WTF\IntegerToStringConversion.cpp" />
<ClCompile Include="..\Tests\WTF\ListHashSet.cpp" />
- <ClCompile Include="..\Tests\WTF\Lock.cpp" />
<ClCompile Include="..\Tests\WTF\MD5.cpp" />
<ClCompile Include="..\Tests\WTF\MathExtras.cpp" />
<ClCompile Include="..\Tests\WTF\MediaTime.cpp" />
@@ -366,4 +365,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
-</Project>
+</Project>
\ No newline at end of file
Modified: trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj (188143 => 188144)
--- trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj 2015-08-07 18:51:00 UTC (rev 188144)
@@ -11,7 +11,6 @@
0F139E781A423A6B00F590F5 /* PlatformUtilitiesCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F139E721A423A2B00F590F5 /* PlatformUtilitiesCocoa.mm */; };
0F139E791A42457000F590F5 /* PlatformUtilitiesCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F139E721A423A2B00F590F5 /* PlatformUtilitiesCocoa.mm */; };
0F3B94A71A77267400DE3272 /* WKWebViewEvaluateJavaScript.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F3B94A51A77266C00DE3272 /* WKWebViewEvaluateJavaScript.mm */; };
- 0FFC45A61B73EBEB0085BD62 /* Lock.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FFC45A41B73EBE20085BD62 /* Lock.cpp */; };
1A02C870125D4CFD00E3F4BD /* find.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 1A02C84B125D4A5E00E3F4BD /* find.html */; };
1A50AA201A2A51FC00F4C345 /* close-from-within-create-page.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 1A50AA1F1A2A4EA500F4C345 /* close-from-within-create-page.html */; };
1A63479F183D72A4005B1707 /* all-content-in-one-iframe.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 93D3D19B17B1A7B000C7C415 /* all-content-in-one-iframe.html */; };
@@ -429,7 +428,6 @@
0F3B94A51A77266C00DE3272 /* WKWebViewEvaluateJavaScript.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKWebViewEvaluateJavaScript.mm; sourceTree = "<group>"; };
0FC6C4CB141027E0005B7F0C /* RedBlackTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RedBlackTree.cpp; sourceTree = "<group>"; };
0FC6C4CE141034AD005B7F0C /* MetaAllocator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MetaAllocator.cpp; sourceTree = "<group>"; };
- 0FFC45A41B73EBE20085BD62 /* Lock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Lock.cpp; sourceTree = "<group>"; };
14464012167A8305000BD218 /* LayoutUnit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LayoutUnit.cpp; sourceTree = "<group>"; };
14F3B11215E45EAB00210069 /* SaturatedArithmeticOperations.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SaturatedArithmeticOperations.cpp; sourceTree = "<group>"; };
1A02C84B125D4A5E00E3F4BD /* find.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = find.html; sourceTree = "<group>"; };
@@ -1098,7 +1096,6 @@
26B2DFF815BDE599004F691D /* HashSet.cpp */,
266FAFD215E5775200F61D5B /* IntegerToStringConversion.cpp */,
26300B1716755CD90066886D /* ListHashSet.cpp */,
- 0FFC45A41B73EBE20085BD62 /* Lock.cpp */,
B4039F9C15E6D8B3007255D6 /* MathExtras.cpp */,
CD5393C71757BA9700C07123 /* MD5.cpp */,
CD5497B315857F0C00B5BC30 /* MediaTime.cpp */,
@@ -1570,7 +1567,6 @@
7CCE7EC91A411A7E00447C4C /* RenderedImageFromDOMNode.mm in Sources */,
7CCE7ECA1A411A7E00447C4C /* RenderedImageFromDOMRange.mm in Sources */,
51CD1C6C1B38CE4300142CA5 /* ModalAlerts.mm in Sources */,
- 0FFC45A61B73EBEB0085BD62 /* Lock.cpp in Sources */,
7CCE7F0E1A411AE600447C4C /* ResizeReversePaginatedWebView.cpp in Sources */,
7CCE7F0F1A411AE600447C4C /* ResizeWindowAfterCrash.cpp in Sources */,
7CCE7F101A411AE600447C4C /* ResponsivenessTimerDoesntFireEarly.cpp in Sources */,
Deleted: trunk/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp (188143 => 188144)
--- trunk/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp 2015-08-07 18:40:22 UTC (rev 188143)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp 2015-08-07 18:51:00 UTC (rev 188144)
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2015 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include <wtf/Lock.h>
-#include <wtf/Threading.h>
-#include <wtf/ThreadingPrimitives.h>
-
-using namespace WTF;
-
-namespace TestWebKitAPI {
-
-template<typename LockType>
-void runLockTest(unsigned numThreadGroups, unsigned numThreadsPerGroup, unsigned workPerCriticalSection, unsigned numIterations)
-{
- std::unique_ptr<LockType[]> locks = std::make_unique<LockType[]>(numThreadGroups);
- std::unique_ptr<double[]> words = std::make_unique<double[]>(numThreadGroups);
- std::unique_ptr<ThreadIdentifier[]> threads = std::make_unique<ThreadIdentifier[]>(numThreadGroups * numThreadsPerGroup);
-
- for (unsigned threadGroupIndex = numThreadGroups; threadGroupIndex--;) {
- words[threadGroupIndex] = 0;
-
- for (unsigned threadIndex = numThreadsPerGroup; threadIndex--;) {
- threads[threadGroupIndex * numThreadsPerGroup + threadIndex] = createThread(
- "Benchmark thread",
- [threadGroupIndex, &locks, &words, numIterations, workPerCriticalSection] () {
- for (unsigned i = numIterations; i--;) {
- locks[threadGroupIndex].lock();
- for (unsigned j = workPerCriticalSection; j--;)
- words[threadGroupIndex]++;
- locks[threadGroupIndex].unlock();
- }
- });
- }
- }
-
- for (unsigned threadIndex = numThreadGroups * numThreadsPerGroup; threadIndex--;)
- waitForThreadCompletion(threads[threadIndex]);
-
- double expected = 0;
- for (uint64_t i = static_cast<uint64_t>(numIterations) * workPerCriticalSection * numThreadsPerGroup; i--;)
- expected++;
-
- for (unsigned threadGroupIndex = numThreadGroups; threadGroupIndex--;)
- EXPECT_EQ(expected, words[threadGroupIndex]);
-}
-
-TEST(WTF_Lock, UncontentedShortSection)
-{
- runLockTest<Lock>(1, 1, 1, 10000000);
-}
-
-TEST(WTF_Lock, UncontentedLongSection)
-{
- runLockTest<Lock>(1, 1, 10000, 1000);
-}
-
-TEST(WTF_Lock, ContentedShortSection)
-{
- runLockTest<Lock>(1, 10, 1, 10000000);
-}
-
-TEST(WTF_Lock, ContentedLongSection)
-{
- runLockTest<Lock>(1, 10, 10000, 10000);
-}
-
-TEST(WTF_Lock, ManyContentedShortSections)
-{
- runLockTest<Lock>(10, 10, 1, 500000);
-}
-
-TEST(WTF_Lock, ManyContentedLongSections)
-{
- runLockTest<Lock>(10, 10, 10000, 1000);
-}
-
-} // namespace TestWebKitAPI
