Fast copy between TypedData and ExternalTypedData

runtime/lib/typeddata.cc

 // Copyright (c) 2013, 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/bootstrap_natives.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/exceptions.h"
@@ skipping 61 matching lines @@
   }
   const String& error = String::Handle(String::NewFormatted(
       "Expected a TypedData object but found %s", instance.ToCString()));
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, error);
   Exceptions::ThrowByType(Exceptions::kArgument, args);
   return Integer::null();
 }
 
 
-#define COPY_DATA(type, dst, src)                                              \
-  const type& dst_array = type::Cast(dst);                                     \
-  const type& src_array = type::Cast(src);                                     \
-  intptr_t element_size_in_bytes = dst_array.ElementSizeInBytes();             \
-  intptr_t length_in_bytes = length.Value() * element_size_in_bytes;           \
-  intptr_t src_offset_in_bytes = src_start.Value() * element_size_in_bytes;    \
-  intptr_t dst_offset_in_bytes = dst_start.Value() * element_size_in_bytes;    \
+#define COPY_DATA_AND_RETURN(dsttype, dst, srctype, src)                       \

[Vyacheslav Egorov (Google), 2013/04/16 14:22:23]

I'd prefer good old template to this huge macro.

+  const dsttype& dst_array = dsttype::Cast(dst);                               \
+  const srctype& src_array = srctype::Cast(src);                               \
+  intptr_t dst_element_size_in_bytes = dst_array.ElementSizeInBytes();         \
+  intptr_t src_element_size_in_bytes = src_array.ElementSizeInBytes();         \
+  intptr_t dst_offset_in_bytes = dst_start.Value() * dst_element_size_in_bytes;\
+  intptr_t src_offset_in_bytes = src_start.Value() * src_element_size_in_bytes;\
+  intptr_t length_in_bytes = length.Value() * src_element_size_in_bytes;       \
+  if (src_element_size_in_bytes != dst_element_size_in_bytes) {                \
+    return Bool::False().raw();                                                \
+  }                                                                            \
   SetRangeCheck(src_offset_in_bytes,                                           \
                 length_in_bytes,                                               \
                 src_array.LengthInBytes(),                                     \
-                element_size_in_bytes);                                        \
+                src_element_size_in_bytes);                                    \
   SetRangeCheck(dst_offset_in_bytes,                                           \
                 length_in_bytes,                                               \
                 dst_array.LengthInBytes(),                                     \
-                element_size_in_bytes);                                        \
-  type::Copy(dst_array, dst_offset_in_bytes,                                   \
-             src_array, src_offset_in_bytes,                                   \
-             length_in_bytes);
+                dst_element_size_in_bytes);                                    \
+  {                                                                            \
+    NoGCScope no_gc;                                                           \
+    if (length_in_bytes > 0) {                                                 \
+      memmove(dst_array.DataAddr(dst_offset_in_bytes),                         \
+              src_array.DataAddr(src_offset_in_bytes),                         \
+              length_in_bytes);                                                \
+    }                                                                          \
+    return Bool::True().raw();                                                 \
+  }
 
 DEFINE_NATIVE_ENTRY(TypedData_setRange, 5) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, dst, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, dst_start, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, src, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, src_start, arguments->NativeArgAt(4));
 
   if (length.Value() < 0) {
     const String& error = String::Handle(String::NewFormatted(
         "length (%"Pd") must be non-negative", length.Value()));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, error);
     Exceptions::ThrowByType(Exceptions::kArgument, args);
   }
-  if ((dst.IsTypedData() || dst.IsExternalTypedData()) &&
-      (dst.clazz() == src.clazz())) {
-    if (dst.IsTypedData()) {
-      ASSERT(src.IsTypedData());
-      COPY_DATA(TypedData, dst, src);
-    } else {
-      ASSERT(src.IsExternalTypedData());
-      ASSERT(dst.IsExternalTypedData());
-      COPY_DATA(ExternalTypedData, dst, src);
+  if (dst.IsTypedData()) {
+    if (src.IsTypedData()) {
+      COPY_DATA_AND_RETURN(TypedData, dst, TypedData, src);
+    } else if (src.IsExternalTypedData()) {
+      COPY_DATA_AND_RETURN(TypedData, dst, ExternalTypedData, src);
     }
-    return Bool::True().raw();
+  } else if (dst.IsExternalTypedData()) {
+    if (src.IsTypedData()) {
+      COPY_DATA_AND_RETURN(ExternalTypedData, dst, TypedData, src);
+    } else if (src.IsExternalTypedData()) {
+      COPY_DATA_AND_RETURN(ExternalTypedData, dst, ExternalTypedData, src);
+    }
   }
   return Bool::False().raw();
 }
 
 
 // We check the length parameter against a possible maximum length for the
 // array based on available physical addressable memory on the system. The
 // maximum possible length is a scaled value of kSmiMax which is set up based
 // on whether the underlying architecture is 32-bit or 64-bit.
 #define TYPED_DATA_NEW(name)                                                   \
@@ skipping 165 matching lines @@
 TYPED_DATA_NATIVES(Uint16Array, GetUint16, SetUint16, Smi, Value)
 TYPED_DATA_NATIVES(Int32Array, GetInt32, SetInt32, Integer, AsInt64Value)
 TYPED_DATA_NATIVES(Uint32Array, GetUint32, SetUint32, Integer, AsInt64Value)
 TYPED_DATA_NATIVES(Int64Array, GetInt64, SetInt64, Integer, AsInt64Value)
 TYPED_DATA_UINT64_NATIVES(Uint64Array, GetUint64, SetUint64, Integer)
 TYPED_DATA_NATIVES(Float32Array, GetFloat32, SetFloat32, Double, value)
 TYPED_DATA_NATIVES(Float64Array, GetFloat64, SetFloat64, Double, value)
 TYPED_DATA_NATIVES(Float32x4Array, GetFloat32x4, SetFloat32x4, Float32x4, value)
 
 }  // namespace dart