Add a first class GrowableObjectArray type in the VM and use it internally in the VM at all spots w…

vm/raw_object_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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 1692 matching lines @@
                object_id,
                kind,
                ObjectStore::kImmutableArrayClass,
                ptr()->tags_,
                ptr()->length_,
                ptr()->type_arguments_,
                ptr()->data());
 }
 
 
+RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
+                                                      intptr_t object_id,
+                                                      intptr_t tags,
+                                                      Snapshot::Kind kind) {
+  ASSERT(reader != NULL);
+
+  // Read the length so that we can determine instance size to allocate.

[cshapiro, 2012/03/06 00:56:31]

Maybe use the common array reader.  See my comment below.

[siva, 2012/03/06 23:32:33]

See my comment below.

On 2012/03/06 00:56:31, cshapiro wrote:

+  intptr_t capacity = reader->ReadIntptrValue();
+  intptr_t length = reader->ReadIntptrValue();
+  GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
+      reader->isolate(), reader->NewGrowableObjectArray());
+  reader->AddBackwardReference(object_id, &array);
+  array.set_capacity(capacity);
+  array.set_length(length);
+  Array& contents = Array::Handle();
+  contents ^= reader->ReadObject();
+  array.set_data(contents);
+  return array.raw();
+}
+
+
+void RawGrowableObjectArray::WriteTo(SnapshotWriter* writer,
+                                     intptr_t object_id,
+                                     Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+
+  // Write out the serialization header value for this object.
+  writer->WriteSerializationMarker(kInlined, object_id);
+
+  // Write out the class and tags information.
+  writer->WriteObjectHeader(ObjectStore::kGrowableObjectArrayClass,
+                            ptr()->tags_);
+
+  // Write out the capacity and length fields.
+  writer->WriteIntptrValue(ptr()->capacity_);

[cshapiro, 2012/03/06 00:56:31]

Hmm... if you get rid of the capacity member you can use ArrayWriteTo here.

The length value just has to be the length of the growable array and you can
write out just that many elements.

The snapshot reader will allocate a fixed array with enough headroom to grow on
the other side.  There is no need to write out the fixed array separately.

[siva, 2012/03/06 23:32:33]

I got rid of the capacity_ field.

I prefer to write out the fixed array as an object here instead of using
ArrayWriteTo because I don't then have to make RawGrowableObjectArray a friend
class of RawArray and add that additional dependency that any changes to
RawArray should also be reflected in the code here.

The only downside to this is some Null objects get written out but these are
just an index and very efficient that I feel it wouldn't become a bottleneck.

On 2012/03/06 00:56:31, cshapiro wrote:

+  writer->WriteIntptrValue(ptr()->length_);
+
+  // Write out the Array object.
+  writer->WriteObject(ptr()->data_);
+}
+
+
 RawByteArray* ByteArray::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   UNREACHABLE();  // ByteArray is an abstract class.
   return ByteArray::null();
 }
 
 
 RawInternalByteArray* InternalByteArray::ReadFrom(SnapshotReader* reader,
@@ skipping 189 matching lines @@
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   UNREACHABLE();
 }
 
 
 }  // namespace dart