Add support for typed data views on native threads

runtime/vm/dart_api_message.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/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
@@ skipping 146 matching lines @@
   value->value.as_array.length = length;
   if (length > 0) {
     value->value.as_array.values = reinterpret_cast<Dart_CObject**>(value + 1);
   } else {
     value->value.as_array.values = NULL;
   }
   return value;
 }
 
 
+Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectInternal(
+    Dart_CObject_Internal::Type type) {
+  Dart_CObject_Internal* value =
+      reinterpret_cast<Dart_CObject_Internal*>(
+          alloc_(NULL, 0, sizeof(Dart_CObject_Internal)));
+  ASSERT(value != NULL);
+  value->type = static_cast<Dart_CObject::Type>(type);
+  return value;
+}
+
+
+Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectClass() {
+  return AllocateDartCObjectInternal(Dart_CObject_Internal::kClass);
+}
+
+
 ApiMessageReader::BackRefNode* ApiMessageReader::AllocateBackRefNode(
     Dart_CObject* reference,
     DeserializeState state) {
   BackRefNode* value =
       reinterpret_cast<BackRefNode*>(alloc_(NULL, 0, sizeof(BackRefNode)));
   value->set_reference(reference);
   value->set_state(state);
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
   USE(tags);
   intptr_t class_id;
 
-  // Reading of regular dart instances is not supported.
+  // There is limited support for reading regular dart instances. Only
+  // typed data views are currently handled.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
-    return AllocateDartCObjectUnsupported();
+    Dart_CObject_Internal* object =
+        reinterpret_cast<Dart_CObject_Internal*>(GetBackRef(object_id));
+    if (object == NULL) {
+      object =
+          AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
+      AddBackRef(object_id, object, kIsDeserialized);
+      // Read class of object.
+      object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
+      ASSERT(object->cls->type ==
+             static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kClass));
+    }
+    ASSERT(object->type ==
+           static_cast<Dart_CObject::Type>(
+               Dart_CObject_Internal::kUninitialized));
+
+    // Handle typed data views.
+    char* library_url =
+        object->cls->internal.as_class.library_url->value.as_string;
+    char* class_name =
+        object->cls->internal.as_class.class_name->value.as_string;
+    if (strcmp("dart:typeddata", library_url) == 0 &&
+        strncmp("_Uint8ArrayView", class_name, 15) == 0) {

[siva, 2013/04/15 20:17:47]

This seems rather inefficient having to do a strcmp to identify the class id
every time.
I am wondering if we should change the writing of TypedData View objects in the
snapshot to be similar to regular TypedData objects (i.e explicitly write out
the class id etc.)

That way reading it back will also be easy.

[Søren Gjesse, 2013/04/17 12:54:58]

That would be a great idea. I added this way of processing a Dart instance as a
temporary solution. There are already specific Cid's for these classes
(kTypedDataUint8ArrayViewCid etc.) - are these already assigned to these
instances?

[siva, 2013/04/18 02:30:40]

Yes these predefined Cid's are already assigned to these instances (look for the
macro REGISTER_TYPED_DATA_VIEW_CLASS in object.cc).

On 2013/04/17 12:54:58, Søren Gjesse wrote:

+      object->type =
+          static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kView);
+      // Skip type arguments.
+      ReadObjectImpl();
+      object->internal.as_view.buffer = ReadObjectImpl();
+      object->internal.as_view.offset_in_bytes = ReadSmiValue();
+      object->internal.as_view.length = ReadSmiValue();
+
+      // The buffer is fully read now as typed data objects are
+      // serialized in-line.
+      Dart_CObject* buffer = object->internal.as_view.buffer;
+      ASSERT(buffer->type == Dart_CObject::kUint8Array);
+
+      // Now turn the view into a byte array.

[siva, 2013/04/15 20:26:30]

Another issue that might need addressing :

if we send an array of typed data view objects and all these typed data view
objects are views to the same typed data object then this scheme of converting
the view to a typed data may not quite work.

[Søren Gjesse, 2013/04/17 12:54:58]

Why is that? The view will just point to the underlying deserialized data. Some
of the tests added in  https://codereview.chromium.org/14200031 should show
this.

[siva, 2013/04/18 02:30:40]

True it would point to the underlying deserialized data but we have now
converted it into a kUint8Array which means it is a regular byte array and
should not share the data with the other view objects which were also converted
into kUint8Array types.

Maybe I am not quite understanding why you need to change the type to
kUint8Array instead of just leaving it as a kView.

+      object->type = Dart_CObject::kUint8Array;
+      object->value.as_byte_array.length = object->internal.as_view.length;
+      object->value.as_byte_array.values =
+          buffer->value.as_byte_array.values +
+          object->internal.as_view.offset_in_bytes;
+    } else {
+      // TODO(sgjesse): Handle other instances. Currently this will
+      // skew the reading as the fields of the instance is not read.
+    }
+    return object;
   }
 
   ASSERT((class_header & kSmiTagMask) != 0);
   class_id = LookupInternalClass(class_header);
   if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = GetBackRef(object_id);
     if (value == NULL) {
       value = AllocateDartCObjectArray(len);
       AddBackRef(object_id, value, kIsDeserialized);
@@ skipping 60 matching lines @@
   if (IsVMIsolateObject(value)) {
     return ReadVMIsolateObject(value);
   }
   if (SerializedHeaderTag::decode(value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(value));
   }
   ASSERT(SerializedHeaderTag::decode(value) == kInlined);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
-  // Reading of regular dart instances is not supported.
+  // Reading of regular dart instances has limited support in order to
+  // read typed data views.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     intptr_t object_id = SerializedHeaderData::decode(value);
-    Dart_CObject* object = AllocateDartCObjectUnsupported();
+    Dart_CObject_Internal* object =
+        AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
     AddBackRef(object_id, object, kIsNotDeserialized);
+    // Read class of object.
+    object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
+    ASSERT(object->cls->type ==
+           static_cast<Dart_CObject::Type>(Dart_CObject_Internal::kClass));
     return object;
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   intptr_t object_id = SerializedHeaderData::decode(value);
   intptr_t class_id = LookupInternalClass(class_header);
   if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
     ASSERT(GetBackRef(object_id) == NULL);
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = AllocateDartCObjectArray(len);
     AddBackRef(object_id, value, kIsNotDeserialized);
@@ skipping 23 matching lines @@
   }
   // No other VM isolate objects are supported.
   return AllocateDartCObjectNull();
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInternalVMObject(intptr_t class_id,
                                                      intptr_t object_id) {
   switch (class_id) {
     case kClassCid: {
-      Dart_CObject* object = AllocateDartCObjectUnsupported();
+      Dart_CObject_Internal* object = AllocateDartCObjectClass();
       AddBackRef(object_id, object, kIsDeserialized);
+      object->internal.as_class.library_url = ReadObjectImpl();
+      ASSERT(object->internal.as_class.library_url->type ==
+             Dart_CObject::kString);
+      object->internal.as_class.class_name = ReadObjectImpl();
+      ASSERT(object->internal.as_class.class_name->type ==
+             Dart_CObject::kString);
       return object;
     }
     case kTypeArgumentsCid: {
       // TODO(sjesse): Remove this when message serialization format is
       // updated (currently length is leaked).
       Dart_CObject* value = &type_arguments_marker;
       AddBackRef(object_id, value, kIsDeserialized);
       Dart_CObject* length = ReadObjectImpl();
       ASSERT(length->type == Dart_CObject::kInt32);
       for (int i = 0; i < length->value.as_int32; i++) {
@@ skipping 582 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart