- Add AtomicOperations::CompareAndSwapWord

runtime/vm/raw_object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
+#include "vm/atomic.h"
 #include "vm/globals.h"
 #include "vm/token.h"
 #include "vm/snapshot.h"
 
 namespace dart {
 
 // Macrobatics to define the Object hierarchy of VM implementation classes.
 #define CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY(V)                           \
   V(Class)                                                                     \
   V(UnresolvedClass)                                                           \
@@ skipping 303 matching lines @@
     return MarkBit::decode(ptr()->tags_);
   }
   void SetMarkBit() {
     ASSERT(!IsMarked());
     uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(true, tags);
   }
   void ClearMarkBit() {
     ASSERT(IsMarked());
     uword tags = ptr()->tags_;
-    ptr()->tags_ = MarkBit::update(false, tags);
+    uword old_tags;
+    do {
+      old_tags = tags;
+      uword new_tags = MarkBit::update(false, old_tags);

[koda, 2014/09/02 04:18:31]

All five changes in this file (and probably some in the other files too) can be
handled by a single template method:

template<typename BitFieldType, typename ValueType>
void RawObject::AtomicUpdateTagField(ValueType new_value) {
  uword tags = ptr()->tags_;
  uword old_tags;
  do {
    old_tags = tags;
    uword new_tags = BitFieldType::update(new_value, old_tags);
    tags = AtomicOperations::CompareAndSwapWord(
        &ptr()->tags_, old_tags, new_tags);
  } while (tags != old_tags);
}

void ClearMarkBit() {
  ASSERT(IsMarked()); 
  AtomicUpdateTagField<MarkBit, bool>(false);
}

etc.

I think this is safer than copy-pasting, especially for synchronization code,
which I find notoriously bug-prone.

Also consider forcing inlining of these methods.

+      tags = AtomicOperations::CompareAndSwapWord(
+          &ptr()->tags_, old_tags, new_tags);
+    } while (tags != old_tags);
   }
 
   // Support for GC watched bit.
   bool IsWatched() const {
     return WatchedBit::decode(ptr()->tags_);
   }
   void SetWatchedBit() {
     ASSERT(!IsWatched());
     uword tags = ptr()->tags_;
     ptr()->tags_ = WatchedBit::update(true, tags);
   }
   void ClearWatchedBit() {
     ASSERT(IsWatched());
     uword tags = ptr()->tags_;
     ptr()->tags_ = WatchedBit::update(false, tags);
   }
 
   // Support for object tags.
   bool IsCanonical() const {
     return CanonicalObjectTag::decode(ptr()->tags_);
   }
   void SetCanonical() {
     uword tags = ptr()->tags_;
-    ptr()->tags_ = CanonicalObjectTag::update(true, tags);
+    uword old_tags;
+    do {
+      old_tags = tags;
+      uword new_tags = CanonicalObjectTag::update(true, old_tags);
+      tags = AtomicOperations::CompareAndSwapWord(
+          &ptr()->tags_, old_tags, new_tags);
+    } while (tags != old_tags);
   }
   bool IsCreatedFromSnapshot() const {
     return CreatedFromSnapshotTag::decode(ptr()->tags_);
   }
   void SetCreatedFromSnapshot() {
     uword tags = ptr()->tags_;
-    ptr()->tags_ = CreatedFromSnapshotTag::update(true, tags);
+    uword old_tags;
+    do {
+      old_tags = tags;
+      uword new_tags = CreatedFromSnapshotTag::update(true, old_tags);
+      tags = AtomicOperations::CompareAndSwapWord(
+          &ptr()->tags_, old_tags, new_tags);
+    } while (tags != old_tags);
   }
 
   // Support for GC remembered bit.
   bool IsRemembered() const {
     return RememberedBit::decode(ptr()->tags_);
   }
   void SetRememberedBit() {
     ASSERT(!IsRemembered());
     uword tags = ptr()->tags_;
-    ptr()->tags_ = RememberedBit::update(true, tags);
+    uword old_tags;
+    do {
+      old_tags = tags;
+      uword new_tags = RememberedBit::update(true, old_tags);
+      tags = AtomicOperations::CompareAndSwapWord(
+          &ptr()->tags_, old_tags, new_tags);
+    } while (tags != old_tags);
   }
   void ClearRememberedBit() {
     uword tags = ptr()->tags_;
-    ptr()->tags_ = RememberedBit::update(false, tags);
+    uword old_tags;
+    do {
+      old_tags = tags;
+      uword new_tags = RememberedBit::update(false, old_tags);
+      tags = AtomicOperations::CompareAndSwapWord(
+          &ptr()->tags_, old_tags, new_tags);
+    } while (tags != old_tags);
   }
 
   bool IsDartInstance() {
     return (!IsHeapObject() || (GetClassId() >= kInstanceCid));
   }
   bool IsFreeListElement() {
     return ((GetClassId() == kFreeListElement));
   }
 
   intptr_t Size() const {
@@ skipping 1609 matching lines @@
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_