- Add AtomicOperations::CompareAndSwapWord

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 780 matching lines @@
 
   // Set up names for object array and one byte string class which are
   // pre-allocated in the vm isolate also.
   cls = Dart::vm_isolate()->object_store()->array_class();
   cls.set_name(Symbols::_List());
   cls = Dart::vm_isolate()->object_store()->one_byte_string_class();
   cls.set_name(Symbols::OneByteString());
 }
 
 
 // Make unused space in an object whose type has been transformed safe

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

Update comment to reflect that this method must now be called *before* updating
the tags of the original object. Also consider ASSERTing that the size of obj,
as obtained from decoding its tags, is still original_size.

 // for traversing during GC.
 // The unused part of the transformed object is marked as an TypedDataInt8Array
 // object.
 void Object::MakeUnusedSpaceTraversable(const Object& obj,
                                         intptr_t original_size,
                                         intptr_t used_size) {
   ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
   ASSERT(!obj.IsNull());
   ASSERT(original_size >= used_size);
   if (original_size > used_size) {
     intptr_t leftover_size = original_size - used_size;
 
     uword addr = RawObject::ToAddr(obj.raw()) + used_size;
     if (leftover_size >= TypedData::InstanceSize(0)) {
-      // Update the leftover space as an TypedDataInt8Array object.
+      // Update the leftover space as a TypedDataInt8Array object.
       RawTypedData* raw =
           reinterpret_cast<RawTypedData*>(RawObject::FromAddr(addr));
-      uword tags = 0;
-      tags = RawObject::SizeTag::update(leftover_size, tags);
-      tags = RawObject::ClassIdTag::update(kTypedDataInt8ArrayCid, tags);
-      raw->ptr()->tags_ = tags;
+      uword new_tags = RawObject::ClassIdTag::update(kTypedDataInt8ArrayCid, 0);
+      new_tags = RawObject::SizeTag::update(leftover_size, new_tags);
+      uword tags = raw->ptr()->tags_;
+      uword old_tags;
+      // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.

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

As long as this update happens strictly before the tags/size update of the
original object (see comment above), I don't think CAS is needed here.

+      do {
+        old_tags = tags;
+        tags = AtomicOperations::CompareAndSwapWord(
+            &raw->ptr()->tags_, old_tags, new_tags);
+      } while (tags != old_tags);
+
       intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
       ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
       raw->ptr()->length_ = Smi::New(leftover_len);
     } else {
       // Update the leftover space as a basic object.
       ASSERT(leftover_size == Object::InstanceSize());
       RawObject* raw = reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
-      uword tags = 0;
-      tags = RawObject::SizeTag::update(leftover_size, tags);
-      tags = RawObject::ClassIdTag::update(kInstanceCid, tags);
-      raw->ptr()->tags_ = tags;
+      uword new_tags = RawObject::ClassIdTag::update(kInstanceCid, 0);
+      new_tags = RawObject::SizeTag::update(leftover_size, new_tags);
+      uword tags = raw->ptr()->tags_;
+      uword old_tags;
+      // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.
+      do {
+        old_tags = tags;
+        tags = AtomicOperations::CompareAndSwapWord(
+            &raw->ptr()->tags_, old_tags, new_tags);
+      } while (tags != old_tags);
     }
   }
 }
 
 
 void Object::VerifyBuiltinVtables() {
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   Class& cls = Class::Handle(isolate, Class::null());
@@ skipping 16343 matching lines @@
                                 Dart_PeerFinalizer cback) const {
   String& result = String::Handle();
   void* external_data;
   Dart_WeakPersistentHandleFinalizer finalizer;
   {
     NoGCScope no_gc;
     ASSERT(array != NULL);
     intptr_t str_length = this->Length();
     ASSERT(length >= (str_length * this->CharSize()));
     intptr_t class_id = raw()->GetClassId();
-    intptr_t used_size = 0;
-    intptr_t original_size = 0;
-    uword tags = raw_ptr()->tags_;
 
     ASSERT(!InVMHeap());
     if (class_id == kOneByteStringCid) {
-      used_size = ExternalOneByteString::InstanceSize();
-      original_size = OneByteString::InstanceSize(str_length);
+      intptr_t used_size = ExternalOneByteString::InstanceSize();
+      intptr_t original_size = OneByteString::InstanceSize(str_length);
       ASSERT(original_size >= used_size);
 
       // Copy the data into the external array.
       if (str_length > 0) {
         memmove(array, OneByteString::CharAddr(*this, 0), str_length);
       }
 
+      // If there is any left over space fill it with either an Array object or

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

is -> will be

+      // just a plain object (depending on the amount of left over space) so
+      // that it can be traversed over successfully during garbage collection.
+      Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
+
       // Update the class information of the object.
       const intptr_t class_id = kExternalOneByteStringCid;
-      tags = RawObject::SizeTag::update(used_size, tags);
-      tags = RawObject::ClassIdTag::update(class_id, tags);
-      raw_ptr()->tags_ = tags;
+      uword tags = raw_ptr()->tags_;
+      uword old_tags;
+      do {
+        old_tags = tags;
+        uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
+        new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
+        tags = AtomicOperations::CompareAndSwapWord(
+            &raw_ptr()->tags_, old_tags, new_tags);
+      } while (tags != old_tags);
       result = this->raw();
       const uint8_t* ext_array = reinterpret_cast<const uint8_t*>(array);
       ExternalStringData<uint8_t>* ext_data = new ExternalStringData<uint8_t>(
           ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalOneByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
       finalizer = ExternalOneByteString::Finalize;
     } else {
       ASSERT(class_id == kTwoByteStringCid);
-      used_size = ExternalTwoByteString::InstanceSize();
-      original_size = TwoByteString::InstanceSize(str_length);
+      intptr_t used_size = ExternalTwoByteString::InstanceSize();
+      intptr_t original_size = TwoByteString::InstanceSize(str_length);
       ASSERT(original_size >= used_size);
 
       // Copy the data into the external array.
       if (str_length > 0) {
         memmove(array,
                 TwoByteString::CharAddr(*this, 0),
                 (str_length * kTwoByteChar));
       }
 
+      // If there is any left over space fill it with either an Array object or

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

Ditto.

+      // just a plain object (depending on the amount of left over space) so
+      // that it can be traversed over successfully during garbage collection.
+      Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
+
       // Update the class information of the object.
       const intptr_t class_id = kExternalTwoByteStringCid;
-      tags = RawObject::SizeTag::update(used_size, tags);
-      tags = RawObject::ClassIdTag::update(class_id, tags);
-      raw_ptr()->tags_ = tags;
+      uword tags = raw_ptr()->tags_;
+      uword old_tags;
+      do {
+        old_tags = tags;
+        uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
+        new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
+        tags = AtomicOperations::CompareAndSwapWord(
+            &raw_ptr()->tags_, old_tags, new_tags);
+      } while (tags != old_tags);
       result = this->raw();
       const uint16_t* ext_array = reinterpret_cast<const uint16_t*>(array);
       ExternalStringData<uint16_t>* ext_data = new ExternalStringData<uint16_t>(
           ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalTwoByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
       finalizer = ExternalTwoByteString::Finalize;
     }
-
-    // If there is any left over space fill it with either an Array object or
-    // just a plain object (depending on the amount of left over space) so
-    // that it can be traversed over successfully during garbage collection.
-    Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
   }  // NoGCScope
   AddFinalizer(result, external_data, finalizer);
   return this->raw();
 }
 
 
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
@@ skipping 795 matching lines @@
     NoGCScope no_gc;
     raw->ptr()->length_ = Smi::New(len);
     return raw;
   }
 }
 
 
 void Array::MakeImmutable() const {
   NoGCScope no_gc;
   uword tags = raw_ptr()->tags_;
-  tags = RawObject::ClassIdTag::update(kImmutableArrayCid, tags);
-  raw_ptr()->tags_ = tags;
+  uword old_tags;
+  do {
+    old_tags = tags;
+    uword new_tags = RawObject::ClassIdTag::update(kImmutableArrayCid,
+                                                   old_tags);
+    tags = AtomicOperations::CompareAndSwapWord(
+        &raw_ptr()->tags_, old_tags, new_tags);
+  } while (tags != old_tags);
 }
 
 
 const char* Array::ToCString() const {
   if (IsNull()) {
     return IsImmutable() ? "_ImmutableList NULL" : "_List NULL";
   }
   const char* format = IsImmutable() ?
       "_ImmutableList len:%" Pd : "_List len:%" Pd;
   intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
@@ skipping 60 matching lines @@
     return Object::empty_array().raw();
   }
   intptr_t capacity_len = growable_array.Capacity();
   Isolate* isolate = Isolate::Current();
   const Array& array = Array::Handle(isolate, growable_array.data());
   array.SetTypeArguments(type_arguments);
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
   intptr_t used_size = Array::InstanceSize(used_len);
   NoGCScope no_gc;
 
+  // If there is any left over space fill it with either an Array object or

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

Ditto.

+  // just a plain object (depending on the amount of left over space) so
+  // that it can be traversed over successfully during garbage collection.
+  Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
+
   // Update the size in the header field and length of the array object.
   uword tags = array.raw_ptr()->tags_;
   ASSERT(kArrayCid == RawObject::ClassIdTag::decode(tags));
-  tags = RawObject::SizeTag::update(used_size, tags);
-  array.raw_ptr()->tags_ = tags;
+  uword old_tags;
+  do {
+    old_tags = tags;
+    uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
+    tags = AtomicOperations::CompareAndSwapWord(
+        &array.raw_ptr()->tags_, old_tags, new_tags);
+  } while (tags != old_tags);
   array.SetLength(used_len);
 
   // Null the GrowableObjectArray, we are removing it's backing array.
   growable_array.SetLength(0);
   growable_array.SetData(Object::empty_array());
 
-  // If there is any left over space fill it with either an Array object or
-  // just a plain object (depending on the amount of left over space) so
-  // that it can be traversed over successfully during garbage collection.
-  Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
-
   return array.raw();
 }
 
 
 bool Array::CheckAndCanonicalizeFields(const char** error_str) const {
   Object& obj = Object::Handle();
   // Iterate over all elements, canonicalize numbers and strings, expect all
   // other instances to be canonical otherwise report error (return false).
   for (intptr_t i = 0; i < Length(); i++) {
     obj = At(i);
@@ skipping 1398 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart