- Add AtomicOperations::CompareAndSwapWord

runtime/vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
+#include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/version.h"
 
 namespace dart {
 
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
@@ skipping 1028 matching lines @@
   }
 }
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
-      object_store_(Isolate::Current()->object_store()),
-      class_table_(Isolate::Current()->class_table()),
+      isolate_(Isolate::Current()),
+      object_store_(isolate_->object_store()),
+      class_table_(isolate_->class_table()),
       forward_list_(kMaxPredefinedObjectIds),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL) {
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
@@ skipping 165 matching lines @@
       return;
     }
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
 }
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  ObjectStore* object_store = isolate->object_store();
+  ASSERT(isolate() != NULL);
+  ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Ensure the class table is valid.
 #if defined(DEBUG)
-  isolate->ValidateClassTable();
+  isolate()->ValidateClassTable();
 #endif
 
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     ReserveHeader();
 
     // Write out the version string.
@@ skipping 24 matching lines @@
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     return forward_list_.NodeForObjectId(id)->tags();
   } else {
     return tags;
   }
 }
 
 
+ForwardList::ForwardList(intptr_t first_object_id)
+    : first_object_id_(first_object_id),
+      nodes_(),
+      first_unprocessed_object_id_(first_object_id) {
+  // The ForwardList encodes information in the header tag word. There cannot

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

cannot -> must not?

I.e., are you saying that this is already guaranteed by other code, or that you
will enforce this using the code below? Seems like the latter to me.

+  // be any concurrent GC tasks while it is in use.
+  PageSpace* page_space = Isolate::Current()->heap()->old_space();
+  MonitorLocker ml(page_space->tasks_lock());
+  while (page_space->tasks() > 0) {
+    ml.Wait();
+  }
+  page_space->set_tasks(1);

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

Do you consider this an actual "task", or are you just (ab)using the task count
to block sweeper tasks from spawning?  Why not add a NoGCScope?

+}
+
+
+ForwardList::~ForwardList() {
+  PageSpace* page_space = Isolate::Current()->heap()->old_space();
+  MonitorLocker ml(page_space->tasks_lock());
+  ASSERT(page_space->tasks() == 1);
+  page_space->set_tasks(0);
+  ml.Notify();
+}
+
+
 intptr_t ForwardList::MarkAndAddObject(RawObject* raw, SerializeState state) {
   NoGCScope no_gc;
   intptr_t object_id = next_object_id();
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) != kObjectId);
   raw->ptr()->tags_ = value;
@@ skipping 289 matching lines @@
                       " : (object extends NativeWrapper)");
   }
 }
 
 
 void SnapshotWriter::SetWriteException(Exceptions::ExceptionType type,
                                        const char* msg) {
   set_exception_type(type);
   set_exception_msg(msg);
   // The more specific error is set up in SnapshotWriter::ThrowException().
-  Isolate::Current()->long_jump_base()->
+  isolate()->long_jump_base()->
       Jump(1, Object::snapshot_writer_error());
 }
 
 
 void SnapshotWriter::WriteInstance(intptr_t object_id,
                                    RawObject* raw,
                                    RawClass* cls,
                                    intptr_t tags) {
   // First check if object is a closure or has native fields.
   CheckIfSerializable(cls);
@@ skipping 44 matching lines @@
   // Indicate this is an instance object.
   WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the class information for this object.
   WriteObjectImpl(cls);
 }
 
 
 void SnapshotWriter::ThrowException(Exceptions::ExceptionType type,
                                     const char* msg) {
-  Isolate::Current()->object_store()->clear_sticky_error();
+  isolate()->object_store()->clear_sticky_error();
   UnmarkAll();
   if (msg != NULL) {
     const String& msg_obj = String::Handle(String::New(msg));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, msg_obj);
     Exceptions::ThrowByType(type, args);
   } else {
     Exceptions::ThrowByType(type, Object::empty_array());
   }
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteVersion() {
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_version), version_len);
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     ReserveHeader();
 
     // Write out the version string.
@@ skipping 22 matching lines @@
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart