Expose transferable constructor to Int8List

runtime/lib/byte_array.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/bootstrap_natives.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
@@ skipping 24 matching lines @@
 static void LengthCheck(intptr_t len, intptr_t max) {
   if (len < 0 || len > max) {
     const String& error = String::Handle(String::NewFormatted(
         "length (%"Pd") must be in the range [0..%"Pd"]", len, max));
     GrowableArray<const Object*> args;
     args.Add(&error);
     Exceptions::ThrowByType(Exceptions::kArgument, args);
   }
 }
 
+#define EXTERNAL_ALIGNMENT 16

[cshapiro, 2012/11/29 21:28:17]

Macros like this are strongly discouraged by the style guide.  

How about making this a static member of ExternalByteArrayData instead?

[Cutch, 2012/11/29 23:53:17]

Done.

+
+void FinalizeExternalBytes(void* ptr) {

[cshapiro, 2012/11/29 21:28:17]

Any reason for this routine?  Why not just pass OS::AlignedFree as the callback?

[Cutch, 2012/11/29 23:53:17]

Done.

+  OS::AlignedFree(ptr);
+}
 
 #define GETTER_ARGUMENTS(ArrayT, ValueT)                                \
   GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));        \
   GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));
 
 
 #define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT)                       \
   GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));        \
   GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));           \
   GET_NATIVE_ARGUMENT(ObjectT, value_object, arguments->NativeArgAt(2));
@@ skipping 223 matching lines @@
 // Int8Array
 
 DEFINE_NATIVE_ENTRY(Int8Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Int8Array::kMaxElements);
   return Int8Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Int8Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Int8Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len*sizeof(int8_t), EXTERNAL_ALIGNMENT);

[cshapiro, 2012/11/29 21:28:17]

I think there are some opportunities for improvement in this code.  First, we
can make OS::AlignedAllocate a template specialized on the type.  This would
internally multiply len by the allocation size and return the correct pointer
type.  This has the added benefit of eliminating the cast on line 298.

[Cutch, 2012/11/29 23:53:17]

Done.

+  return ExternalInt8Array::New(reinterpret_cast<int8_t*>(bytes),
+                                len,
+                                bytes,
+                                FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) {
   GETTER(Int8Array, Smi, int8_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) {
   SETTER(Int8Array, Smi, Value, int8_t);
 }
 
 
 // Uint8Array
 
 DEFINE_NATIVE_ENTRY(Uint8Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Uint8Array::kMaxElements);
   return Uint8Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Uint8Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Uint8Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(uint8_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalUint8Array::New(reinterpret_cast<uint8_t*>(bytes),
+                                len,
+                                bytes,
+                                FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Uint8Array_getIndexed, 2) {
   GETTER(Uint8Array, Smi, uint8_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Uint8Array_setIndexed, 3) {
   SETTER(Uint8Array, Smi, Value, uint8_t);
 }
 
 
 // Int16Array
 
 DEFINE_NATIVE_ENTRY(Int16Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Int16Array::kMaxElements);
   return Int16Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Int16Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Int16Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(int16_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalInt16Array::New(reinterpret_cast<int16_t*>(bytes),
+                                 len,
+                                 bytes,
+                                 FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Int16Array_getIndexed, 2) {
   GETTER(Int16Array, Smi, int16_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int16Array_setIndexed, 3) {
   SETTER(Int16Array, Smi, Value, int16_t);
 }
 
 
 // Uint16Array
 
 DEFINE_NATIVE_ENTRY(Uint16Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Uint16Array::kMaxElements);
   return Uint16Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Uint16Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Uint16Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(uint16_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalUint16Array::New(reinterpret_cast<uint16_t*>(bytes),
+                                  len,
+                                  bytes,
+                                  FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Uint16Array_getIndexed, 2) {
   GETTER(Uint16Array, Smi, uint16_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Uint16Array_setIndexed, 3) {
   SETTER(Uint16Array, Smi, Value, uint16_t);
 }
 
 
 // Int32Array
 
 DEFINE_NATIVE_ENTRY(Int32Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Int32Array::kMaxElements);
   return Int32Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Int32Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Int32Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(int32_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalInt32Array::New(reinterpret_cast<int32_t*>(bytes),
+                                 len,
+                                 bytes,
+                                 FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Int32Array_getIndexed, 2) {
   GETTER(Int32Array, Integer, int32_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int32Array_setIndexed, 3) {
   SETTER(Int32Array, Integer, AsInt64Value, int32_t);
 }
 
 
 // Uint32Array
 
 DEFINE_NATIVE_ENTRY(Uint32Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Uint32Array::kMaxElements);
   return Uint32Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Uint32Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Uint32Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(uint32_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalUint32Array::New(reinterpret_cast<uint32_t*>(bytes),
+                                  len,
+                                  bytes,
+                                  FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Uint32Array_getIndexed, 2) {
   GETTER(Uint32Array, Integer, uint32_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Uint32Array_setIndexed, 3) {
   SETTER(Uint32Array, Integer, AsInt64Value, uint32_t);
 }
 
 
 // Int64Array
 
 DEFINE_NATIVE_ENTRY(Int64Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Int64Array::kMaxElements);
   return Int64Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Int64Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Int64Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(int64_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalInt64Array::New(reinterpret_cast<int64_t*>(bytes),
+                                 len,
+                                 bytes,
+                                 FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Int64Array_getIndexed, 2) {
   GETTER(Int64Array, Integer, int64_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int64Array_setIndexed, 3) {
   SETTER(Int64Array, Integer, AsInt64Value, int64_t);
 }
 
 
 // Uint64Array
 
 DEFINE_NATIVE_ENTRY(Uint64Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Uint64Array::kMaxElements);
   return Uint64Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Uint64Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Uint64Array::kMaxElements);
+  void* bytes = OS::AlignedAllocate(len * sizeof(uint64_t),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalUint64Array::New(reinterpret_cast<uint64_t*>(bytes),
+                                  len,
+                                  bytes,
+                                  FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Uint64Array_getIndexed, 2) {
   GETTER_UINT64(Uint64Array);
 }
 
 
 DEFINE_NATIVE_ENTRY(Uint64Array_setIndexed, 3) {
   SETTER_UINT64(Uint64Array);
 }
 
 
 // Float32Array
 
 DEFINE_NATIVE_ENTRY(Float32Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Float32Array::kMaxElements);
   return Float32Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Float32Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Float32Array::kMaxElements);
+  float foo;  // quiet cpplint.

[cshapiro, 2012/11/29 21:28:17]

cpplint does not want you using sizeof(<typename>) in general.  The stdint types
above should also be flagged but cpplint is not smart enough to catch that.

I think we have a better fix for this problem by tweaking AlignedAllocate.  If
that was not the case, a "// NOLINT" comment at the end of the offending line is
the right way to muffle cpplint.

[Cutch, 2012/11/29 23:53:17]

Done.

+  void* bytes = OS::AlignedAllocate(len * sizeof(foo),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalFloat32Array::New(reinterpret_cast<float*>(bytes),
+                                   len,
+                                   bytes,
+                                   FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Float32Array_getIndexed, 2) {
   GETTER(Float32Array, Double, float);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32Array_setIndexed, 3) {
   SETTER(Float32Array, Double, value, float);
 }
 
 
 // Float64Array
 
 DEFINE_NATIVE_ENTRY(Float64Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Float64Array::kMaxElements);
   return Float64Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Float64Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Float64Array::kMaxElements);
+  double foo;  // quiet cpplint.
+  void* bytes = OS::AlignedAllocate(len * sizeof(foo),
+                                    EXTERNAL_ALIGNMENT);
+  return ExternalFloat64Array::New(reinterpret_cast<double*>(bytes),
+                                   len,
+                                   bytes,
+                                   FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Float64Array_getIndexed, 2) {
   GETTER(Float64Array, Double, double);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float64Array_setIndexed, 3) {
   SETTER(Float64Array, Double, value, double);
 }
 
 
@@ skipping 110 matching lines @@
 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) {
   GETTER(ExternalFloat64Array, Double, double);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) {
   SETTER(ExternalFloat64Array, Double, value, double);
 }
 
 }  // namespace dart