Use Heap::kOld when allocating objects for script snapshots.

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/exceptions.h"
@@ skipping 96 matching lines @@
     return kStringInterface;
   } else if (raw_type == object_store->list_interface()) {
     return kListInterface;
   } else if (raw_type == object_store->byte_array_interface()) {
     return kByteArrayInterface;
   }
   return kInvalidIndex;
 }
 
 
+static Heap::Space space(Snapshot::Kind kind) {

[cshapiro, 2012/08/25 03:30:11]

Is this change missing heap.h or am I confused?

Lowercase method names are reserved for getters and setters and other, likely to
be in-lined, functions.  Having this be an out of line static function is a
little bit iffy given the context.  My preference would be to capitalize this
and make it look like any other ordinary method call or hoisting this out into
heap.h to have a similar effect.

[siva, 2012/08/27 17:15:21]

I would have preferred to put this in snapshot.h but it causes cyclic dependency
issues as snapshot.h is included in  raw_object.h which is included in
scavenger.h

I have made this a macro HEAPSPACE(kind).

On 2012/08/25 03:30:11, cshapiro wrote:

+  return (kind == Snapshot::kMessage) ? Heap::kNew : Heap::kOld;
+}
+
+
 // TODO(5411462): Temporary setup of snapshot for testing purposes,
 // the actual creation of a snapshot maybe done differently.
 const Snapshot* Snapshot::SetupFromBuffer(const void* raw_memory) {
   ASSERT(raw_memory != NULL);
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == kind_offset());
   ASSERT((kHeapObjectTag & kInlined));
   // No object can have kFreeBit and kMarkBit set simultaneously. If kFreeBit
   // is set then the rest of tags is a pointer to the next FreeListElement which
@@ skipping 64 matching lines @@
     cls = library_.LookupClass(str_);
   }
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
-    return Integer::New((value >> kSmiTagShift));
+    return Integer::New((value >> kSmiTagShift), space(kind_));
   }
   return ReadObjectImpl(value);
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
     return ReadInlinedObject(SerializedHeaderData::decode(header_value));
   }
 }
 
 
 RawObject* SnapshotReader::ReadObjectRef() {
   int64_t header_value = Read<int64_t>();
   if ((header_value & kSmiTagMask) == 0) {
-    return Integer::New((header_value >> kSmiTagShift));
+    return Integer::New((header_value >> kSmiTagShift), space(kind_));
   }
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else if (SerializedHeaderTag::decode(header_value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(header_value));
   }
   ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
   intptr_t object_id = SerializedHeaderData::decode(header_value);
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
     AddBackRef(object_id, &result, kIsNotDeserialized);
 
     cls_ ^= ReadObjectImpl();  // Read class information.
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_, instance_size);
     } else {
-      result ^= Object::Allocate(cls_.id(), instance_size, Heap::kNew);
+      result ^= Object::Allocate(cls_.id(), instance_size, space(kind_));
     }
     return result.raw();
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   cls_ = LookupInternalClass(class_header);
   ASSERT(!cls_.IsNull());
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
   intptr_t class_id = cls_.id();
   if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
         isolate(),
-        (kind_ == Snapshot::kFull) ? NewArray(len) : Array::New(len));
+        ((kind_ == Snapshot::kFull) ?
+         NewArray(len) : Array::New(len, space(kind_))));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
   if (class_id == kImmutableArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     ImmutableArray& array = ImmutableArray::ZoneHandle(
         isolate(),
         (kind_ == Snapshot::kFull) ?
-          NewImmutableArray(len) : ImmutableArray::New(len));
+        NewImmutableArray(len) : ImmutableArray::New(len, space(kind_)));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
 
   // For all other internal VM classes we read the object inline.
   intptr_t tags = ReadIntptrValue();
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
@@ skipping 363 matching lines @@
       result = &(Instance::ZoneHandle(isolate(), Instance::null()));
       AddBackRef(object_id, result, kIsDeserialized);
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
       ASSERT(instance_size > 0);
       // Allocate the instance and read in all the fields for the object.
       if (kind_ == Snapshot::kFull) {
         *result ^= AllocateUninitialized(cls_, instance_size);
       } else {
-        *result ^= Object::Allocate(cls_.id(), instance_size, Heap::kNew);
+        *result ^= Object::Allocate(cls_.id(), instance_size, space(kind_));
       }
     } else {
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
     }
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
       obj_ = ReadObjectRef();
       result->SetFieldAtOffset(offset, obj_);
@@ skipping 465 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 }  // namespace dart