Changeset 153132 in webkit for trunk/Source/JavaScriptCore/runtime/JSSymbolTableObject.h

Timestamp:

Jul 24, 2013, 8:59:04 PM (12 years ago)

Author:

[email protected]

Message:

fourthTier: SymbolTable should be thread-safe
​https://bugs.webkit.org/show_bug.cgi?id=115301

Reviewed by Geoffrey Garen.

Makes SymbolTable thread-safe. Relies on SymbolTableEntry already being immutable,
other than the WatchpointSet; but the WatchpointSet already has a righteous
concurrency protocol. So, this patch just protects the SymbolTable's HashMap.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::nameForRegister):

• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::addVar):

• runtime/Executable.cpp:

(JSC::ProgramExecutable::addGlobalVar):

• runtime/JSActivation.cpp:

(JSC::JSActivation::getOwnNonIndexPropertyNames):
(JSC::JSActivation::symbolTablePutWithAttributes):

• runtime/JSSymbolTableObject.cpp:

(JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):

• runtime/JSSymbolTableObject.h:

(JSC::symbolTableGet):
(JSC::symbolTablePut):
(JSC::symbolTablePutWithAttributes):

• runtime/SymbolTable.cpp:

(JSC::SymbolTable::SymbolTable):
(JSC::SymbolTable::~SymbolTable):

• runtime/SymbolTable.h:

(JSC::SymbolTable::find):
(JSC::SymbolTable::get):
(JSC::SymbolTable::inlineGet):
(JSC::SymbolTable::begin):
(JSC::SymbolTable::end):
(JSC::SymbolTable::size):
(JSC::SymbolTable::add):
(JSC::SymbolTable::set):
(JSC::SymbolTable::contains):

File:

• trunk/Source/JavaScriptCore/runtime/JSSymbolTableObject.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/runtime/JSSymbolTableObject.h

@@ -74 +74 @@
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::iterator iter = symbolTable.find(propertyName.publicName());
-    if (iter == symbolTable.end())
+    SymbolTable::Locker locker(symbolTable.m_lock);
+    SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
+    if (iter == symbolTable.end(locker))
         return false;
     SymbolTableEntry::Fast entry = iter->value;
@@ -88 +89 @@
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::iterator iter = symbolTable.find(propertyName.publicName());
-    if (iter == symbolTable.end())
+    SymbolTable::Locker locker(symbolTable.m_lock);
+    SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
+    if (iter == symbolTable.end(locker))
         return false;
     SymbolTableEntry::Fast entry = iter->value;
@@ -104 +106 @@
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::iterator iter = symbolTable.find(propertyName.publicName());
-    if (iter == symbolTable.end())
+    SymbolTable::Locker locker(symbolTable.m_lock);
+    SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
+    if (iter == symbolTable.end(locker))
         return false;
     SymbolTableEntry::Fast entry = iter->value;
@@ -122 +125 @@
     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(object));
     
-    SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::iterator iter = symbolTable.find(propertyName.publicName());
-    if (iter == symbolTable.end())
-        return false;
-    bool wasFat;
-    SymbolTableEntry::Fast fastEntry = iter->value.getFast(wasFat);
-    ASSERT(!fastEntry.isNull());
-    if (fastEntry.isReadOnly()) {
-        if (shouldThrow)
-            throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
-        return true;
+    WriteBarrierBase<Unknown>* reg;
+    {
+        SymbolTable& symbolTable = *object->symbolTable();
+        SymbolTable::Locker locker(symbolTable.m_lock);
+        SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
+        if (iter == symbolTable.end(locker))
+            return false;
+        bool wasFat;
+        SymbolTableEntry::Fast fastEntry = iter->value.getFast(wasFat);
+        ASSERT(!fastEntry.isNull());
+        if (fastEntry.isReadOnly()) {
+            if (shouldThrow)
+                throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
+            return true;
+        }
+        if (UNLIKELY(wasFat))
+            iter->value.notifyWrite();
+        reg = &object->registerAt(fastEntry.getIndex());
     }
-    if (UNLIKELY(wasFat))
-        iter->value.notifyWrite();
-    object->registerAt(fastEntry.getIndex()).set(vm, object, value);
+    // I'd prefer we not hold lock while executing barriers, since I prefer to reserve
+    // the right for barriers to be able to trigger GC. And I don't want to hold VM
+    // locks while GC'ing.
+    reg->set(vm, object, value);
     return true;
 }
@@ -146 +157 @@
 {
     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(object));
-    
-    SymbolTable::iterator iter = object->symbolTable()->find(propertyName.publicName());
-    if (iter == object->symbolTable()->end())
-        return false;
-    SymbolTableEntry& entry = iter->value;
-    ASSERT(!entry.isNull());
-    entry.notifyWrite();
-    entry.setAttributes(attributes);
-    object->registerAt(entry.getIndex()).set(vm, object, value);
+
+    WriteBarrierBase<Unknown>* reg;
+    {
+        SymbolTable& symbolTable = *object->symbolTable();
+        SymbolTable::Locker locker(symbolTable.m_lock);
+        SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
+        if (iter == symbolTable.end(locker))
+            return false;
+        SymbolTableEntry& entry = iter->value;
+        ASSERT(!entry.isNull());
+        entry.notifyWrite();
+        entry.setAttributes(attributes);
+        reg = &object->registerAt(entry.getIndex());
+    }
+    reg->set(vm, object, value);
     return true;
 }