Fast copy between TypedData and ExternalTypedData

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 5016 matching lines @@
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   intptr_t ElementSizeInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
+  intptr_t ElementType() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementType(cid);

[kustermann, 2013/04/16 17:26:04]

It is not the nicest thing that these functions return 'intptr_t'.

Alternatively, I could add a field to TypedData/ExternalTypedData which stores
it's "TypedDataType".

[Vyacheslav Egorov (Google), 2013/04/17 11:41:56]

Why not introduce an enum:

enum TypeDataElementType {
#define V(name) k##name##Element,
}

and then use it here? (cast result to it). 

[Vyacheslav Egorov (Google), 2013/04/17 12:55:27]

I meant:

enum TypeDataElementType {
#define V(name) k##name##Element,
CLASS_LIST_TYPED_DATA(V)
#undef V
}

On 2013/04/17 11:41:56, Vyacheslav Egorov (Google) wrote:

[kustermann, 2013/04/18 13:57:57]

Done.

+  }
+
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* DataAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < LengthInBytes()));
     return reinterpret_cast<void*>(raw_ptr()->data_ + byte_offset);
   }
 
@@ skipping 32 matching lines @@
   static intptr_t InstanceSize(intptr_t lengthInBytes) {
     ASSERT(0 <= lengthInBytes && lengthInBytes <= kSmiMax);
     return RoundedAllocationSize(sizeof(RawTypedData) + lengthInBytes);
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
     return element_size[class_id - kTypedDataInt8ArrayCid];
   }
 
+  static intptr_t ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsTypedDataClassId(class_id));
+    return class_id - kTypedDataInt8ArrayCid;
+  }
+
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawTypedData* New(intptr_t class_id,
                            intptr_t len,
                            Heap::Space space = Heap::kNew);
 
   static void Copy(const TypedData& dst,
@@ skipping 28 matching lines @@
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   intptr_t ElementSizeInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
+  intptr_t ElementType() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementType(cid);
+  }
+
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* GetPeer() const {
     return raw_ptr()->peer_;
   }
 
   void* DataAddr(intptr_t byte_offset) const {
@@ skipping 33 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalTypedData));
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
     return TypedData::element_size[class_id - kExternalTypedDataInt8ArrayCid];
   }
 
+  static intptr_t ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
+    return class_id - kExternalTypedDataInt8ArrayCid;
+  }
+
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawExternalTypedData* New(intptr_t class_id,
                                    uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
@@ skipping 456 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_