Update tag bits atomically

runtime/vm/gc_marker.cc

 // Copyright (c) 2011, 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/gc_marker.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
@@ skipping 140 matching lines @@
     return &skipped_code_functions_;
   }
 
   void DelayWeakProperty(RawWeakProperty* raw_weak) {
     RawObject* raw_key = raw_weak->ptr()->key_;
     DelaySet::iterator it = delay_set_.find(raw_key);
     if (it != delay_set_.end()) {
       ASSERT(raw_key->IsWatched());
     } else {
       ASSERT(!raw_key->IsWatched());
-      raw_key->SetWatchedBit();
+      raw_key->SetWatchedBitUnsynchronized();
     }
     delay_set_.insert(std::make_pair(raw_key, raw_weak));
   }
 
   void Finalize() {
     DelaySet::iterator it = delay_set_.begin();
     for (; it != delay_set_.end(); ++it) {
       WeakProperty::Clear(it->second);
     }
     if (!visit_function_code_) {
       DetachCode();
     }
   }
 
   void VisitingOldObject(RawObject* obj) {
     ASSERT((obj == NULL) || obj->IsOldObject());
     visiting_old_object_ = obj;
   }
 
  private:
   void MarkAndPush(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
     ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc) ?
            page_space_->Contains(RawObject::ToAddr(raw_obj)) :
            true);
 
     // Mark the object and push it on the marking stack.
     ASSERT(!raw_obj->IsMarked());
-    raw_obj->SetMarkBit();
-    raw_obj->ClearRememberedBit();
-    if (raw_obj->IsWatched()) {
+    const bool is_watched = raw_obj->IsWatched();
+    raw_obj->SetMarkBitUnsynchronized();
+    raw_obj->ClearRememberedBitUnsynchronized();
+    raw_obj->ClearWatchedBitUnsynchronized();
+    if (is_watched) {
       std::pair<DelaySet::iterator, DelaySet::iterator> ret;
       // Visit all elements with a key equal to raw_obj.
       ret = delay_set_.equal_range(raw_obj);
       // Create a copy of the range in a temporary vector to iterate over it
       // while delay_set_ may be modified.
       std::vector<DelaySetEntry> temp_copy(ret.first, ret.second);
       delay_set_.erase(ret.first, ret.second);
       for (std::vector<DelaySetEntry>::iterator it = temp_copy.begin();
            it != temp_copy.end(); ++it) {
         it->second->VisitPointers(this);
       }
-      raw_obj->ClearWatchedBit();
     }
     marking_stack_->Push(raw_obj);
   }
 
   void MarkObject(RawObject* raw_obj, RawObject** p) {
     // Fast exit if the raw object is a Smi.
     if (!raw_obj->IsHeapObject()) {
       return;
     }
 
     // Fast exit if the raw object is marked.
     if (raw_obj->IsMarked()) {
       return;
     }
 
     // Skip over new objects, but verify consistency of heap while at it.
     if (raw_obj->IsNewObject()) {
       // TODO(iposva): Add consistency check.
       if ((visiting_old_object_ != NULL) &&
           !visiting_old_object_->IsRemembered()) {
         ASSERT(p != NULL);
-        visiting_old_object_->SetRememberedBit();
+        visiting_old_object_->SetRememberedBitUnsynchronized();
         isolate()->store_buffer()->AddObjectGC(visiting_old_object_);
       }
       return;
     }
     if (RawObject::IsVariableSizeClassId(raw_obj->GetClassId())) {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), raw_obj->Size());
     } else {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), 0);
     }
 
@@ skipping 273 matching lines @@
   MarkingWeakVisitor mark_weak;
   IterateWeakRoots(isolate, &mark_weak, invoke_api_callbacks);
   mark.Finalize();
   ProcessWeakTables(page_space);
   ProcessObjectIdTable(isolate);
 
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart