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);
   }
 
+
+  TypeDataElementType ElementType() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementType(cid);
+  }
+
   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 29 matching lines @@
     return 0;
   }
 
   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];

[siva, 2013/04/19 17:38:40]

you could use your new ElementType() here instead of
class_id - kTypedDataInt8ArrayCid

[kustermann, 2013/04/19 19:21:54]

Done.

[kustermann, 2013/04/19 19:21:54]

Done.

   }
 
+  static TypeDataElementType ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsTypedDataClassId(class_id));
+    return static_cast<TypeDataElementType>(
+        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);
   }
 
+  TypeDataElementType 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 30 matching lines @@
   static intptr_t data_offset() {
     return OFFSET_OF(RawExternalTypedData, data_);
   }
 
   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];

[siva, 2013/04/19 17:38:40]

Ditto comment about using the new ElementType

[kustermann, 2013/04/19 19:21:54]

Done.

   }
 
+  static TypeDataElementType ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
+    return static_cast<TypeDataElementType>(
+        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 21 matching lines @@
   void SetPeer(void* peer) const {
     raw_ptr()->peer_ = peer;
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData, Instance);
   friend class Class;
 };
 
 
+template <typename DstType, typename SrcType>
+void TypedArrayCopyData(const DstType& dst, intptr_t dst_offset_in_bytes,
+                        const SrcType& src, intptr_t src_offset_in_bytes,
+                        intptr_t length_in_bytes) {
+  ASSERT(dst.ElementType() == src.ElementType());
+  ASSERT(Utils::RangeCheck(src_offset_in_bytes,
+                           length_in_bytes,
+                           src.LengthInBytes()));
+  ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
+                           length_in_bytes,
+                           dst.LengthInBytes()));
+  {
+    NoGCScope no_gc;
+    if (length_in_bytes > 0) {
+      memmove(dst.DataAddr(dst_offset_in_bytes),
+              src.DataAddr(src_offset_in_bytes),
+              length_in_bytes);
+    }
+  }
+}

[siva, 2013/04/19 17:38:40]

Why not make this the static function of class TypedData.
i.e:

class TypedData {
  .....
  .....
  template<typename DstType, typename SrcType>
  static void Copy(const DstType& dst, intptr_t dst_offset_in_bytes,
                   const SrcType& src, intptr_t src_offset_in_bytes,
                   intptr_t length_in_bytes) {
    add the code you have in TypedArrayCopyData here....
  }
  ....
  ....
};

Get rid of the Copy function in ExternalTypedData, everybody would use the
templatized copy function you define above.

[kustermann, 2013/04/19 19:21:54]

Done.

+
+
 class TypedDataView : public AllStatic {
  public:
   static intptr_t ElementSizeInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
     intptr_t cid = view_obj.raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
@@ skipping 415 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_