- Change the layout of external typed array objects to avoid the extra indirection when accessing e…

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 17875)
+++ runtime/vm/object.cc	(working copy)
@@ -273,6 +273,16 @@
 }
 
 
+static void DeleteWeakPersistentHandle(Dart_Handle handle) {
+  ApiState* state = Isolate::Current()->api_state();
+  ASSERT(state != NULL);
+  FinalizablePersistentHandle* weak_ref =
+      reinterpret_cast<FinalizablePersistentHandle*>(handle);
+  ASSERT(state->IsValidWeakPersistentHandle(handle));
+  state->weak_persistent_handles().FreeHandle(weak_ref);
+}
+
+
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
@@ -4749,9 +4759,10 @@
 }
 
 
-void TokenStream::DataFinalizer(void *peer) {
+void TokenStream::DataFinalizer(Dart_Handle handle, void *peer) {
   ASSERT(peer != NULL);
   ::free(peer);
+  DeleteWeakPersistentHandle(handle);
 }
 
 
@@ -4967,7 +4978,8 @@
   uint8_t* data = reinterpret_cast<uint8_t*>(::malloc(len));
   ASSERT(data != NULL);
   const ExternalUint8Array& stream = ExternalUint8Array::Handle(
-      ExternalUint8Array::New(data, len, data, DataFinalizer, Heap::kOld));
+      ExternalUint8Array::New(data, len, Heap::kOld));
+  stream.AddFinalizer(data, DataFinalizer);
   const TokenStream& result = TokenStream::Handle(TokenStream::New());
   result.SetStream(stream);
   return result.raw();
@@ -5140,11 +5152,8 @@
 
   // Create and setup the token stream object.
   const ExternalUint8Array& stream = ExternalUint8Array::Handle(
-      ExternalUint8Array::New(data.GetStream(),
-                              data.Length(),
-                              data.GetStream(),
-                              DataFinalizer,
-                              Heap::kOld));
+      ExternalUint8Array::New(data.GetStream(), data.Length(), Heap::kOld));
+  stream.AddFinalizer(data.GetStream(), DataFinalizer);
   const TokenStream& result = TokenStream::Handle(New());
   result.SetPrivateKey(private_key);
   {
@@ -11002,10 +11011,12 @@
 }
 
 
-static void AddFinalizer(const Object& referent,
-                         void* peer,
-                         Dart_WeakPersistentHandleFinalizer callback) {
-  ASSERT(callback != NULL);
+static FinalizablePersistentHandle* AddFinalizer(
+    const Object& referent,
+    void* peer,
+    Dart_WeakPersistentHandleFinalizer callback) {
+  ASSERT((callback != NULL && peer != NULL) ||
+         (callback == NULL && peer == NULL));
   ApiState* state = Isolate::Current()->api_state();
   ASSERT(state != NULL);
   FinalizablePersistentHandle* weak_ref =
@@ -11013,6 +11024,7 @@
   weak_ref->set_raw(referent);
   weak_ref->set_peer(peer);
   weak_ref->set_callback(callback);
+  return weak_ref;
 }
 
 
@@ -11616,16 +11628,6 @@
 }
 
 
-static void DeleteWeakPersistentHandle(Dart_Handle handle) {
-  ApiState* state = Isolate::Current()->api_state();
-  ASSERT(state != NULL);
-  FinalizablePersistentHandle* weak_ref =
-      reinterpret_cast<FinalizablePersistentHandle*>(handle);
-  ASSERT(state->IsValidWeakPersistentHandle(handle));
-  state->weak_persistent_handles().FreeHandle(weak_ref);
-}
-
-
 void ExternalOneByteString::Finalize(Dart_Handle handle, void* peer) {
   delete reinterpret_cast<ExternalStringData<uint8_t>*>(peer);
   DeleteWeakPersistentHandle(handle);
@@ -11981,19 +11983,10 @@
 }
 
 
-template<typename T>
-static void ExternalByteArrayFinalize(Dart_Handle handle, void* peer) {
-  delete reinterpret_cast<ExternalByteArrayData<T>*>(peer);
-  DeleteWeakPersistentHandle(handle);
-}
-
-
 template<typename HandleT, typename RawT, typename ElementT>
 RawT* ByteArray::NewExternalImpl(intptr_t class_id,
                                  ElementT* data,
                                  intptr_t len,
-                                 void* peer,
-                                 Dart_PeerFinalizer callback,
                                  Heap::Space space) {
   if (len < 0 || len > HandleT::kMaxElements) {
     // This should be caught before we reach here.
@@ -12001,16 +11994,13 @@
            len);
   }
   HandleT& result = HandleT::Handle();
-  ExternalByteArrayData<ElementT>* external_data =
-      new ExternalByteArrayData<ElementT>(data, peer, callback);
   {
     RawObject* raw = Object::Allocate(class_id, HandleT::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
-    result.SetExternalData(external_data);
+    result.SetData(data);
   }
-  AddFinalizer(result, external_data, ExternalByteArrayFinalize<ElementT>);
   return result.raw();
 }
 
@@ -12022,6 +12012,14 @@
 }
 
 
+FinalizablePersistentHandle* ByteArray::AddFinalizer(
+    void* peer,
+    Dart_WeakPersistentHandleFinalizer callback) const {
+  SetPeer(peer);
+  return dart::AddFinalizer(*this, peer, callback);
+}
+
+
 uint8_t* ByteArray::ByteAddr(intptr_t byte_offset) const {
   // ByteArray is an abstract class.
   UNREACHABLE();
@@ -12317,13 +12315,11 @@
 
 RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
                                              intptr_t len,
-                                             void* peer,
-                                             Dart_PeerFinalizer callback,
                                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int8_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt8Array,
+                         RawExternalInt8Array>(kClassId, data, len, space);
 }
 
 
@@ -12334,13 +12330,11 @@
 
 RawExternalUint8Array* ExternalUint8Array::New(uint8_t* data,
                                                intptr_t len,
-                                               void* peer,
-                                               Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_uint8_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint8Array,
+                         RawExternalUint8Array>(kClassId, data, len, space);
 }
 
 
@@ -12352,14 +12346,13 @@
 RawExternalUint8ClampedArray* ExternalUint8ClampedArray::New(
     uint8_t* data,
     intptr_t len,
-    void* peer,
-    Dart_PeerFinalizer callback,
     Heap::Space space) {
   ASSERT(Isolate::Current()->
-             object_store()->external_uint8_clamped_array_class() !=
+         object_store()->external_uint8_clamped_array_class() !=
          Class::null());
   return NewExternalImpl<ExternalUint8ClampedArray,
-      RawExternalUint8ClampedArray>(kClassId, data, len, peer, callback, space);
+                         RawExternalUint8ClampedArray>(kClassId, data,
+                                                       len, space);
 }
 
 
@@ -12370,13 +12363,11 @@
 
 RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
                                                intptr_t len,
-                                               void* peer,
-                                               Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int16_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt16Array,
+                         RawExternalInt16Array>(kClassId, data, len, space);
 }
 
 
@@ -12387,13 +12378,11 @@
 
 RawExternalUint16Array* ExternalUint16Array::New(uint16_t* data,
                                                  intptr_t len,
-                                                 void* peer,
-                                                 Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_uint16_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint16Array, RawExternalUint16Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint16Array,
+                         RawExternalUint16Array>(kClassId, data, len, space);
 }
 
 
@@ -12404,13 +12393,11 @@
 
 RawExternalInt32Array* ExternalInt32Array::New(int32_t* data,
                                                intptr_t len,
-                                               void* peer,
-                                               Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt32Array, RawExternalInt32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt32Array,
+                         RawExternalInt32Array>(kClassId, data, len, space);
 }
 
 
@@ -12421,13 +12408,11 @@
 
 RawExternalUint32Array* ExternalUint32Array::New(uint32_t* data,
                                                  intptr_t len,
-                                                 void* peer,
-                                                 Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_uint32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint32Array, RawExternalUint32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint32Array,
+                         RawExternalUint32Array>(kClassId, data, len, space);
 }
 
 
@@ -12438,13 +12423,11 @@
 
 RawExternalInt64Array* ExternalInt64Array::New(int64_t* data,
                                                intptr_t len,
-                                               void* peer,
-                                               Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt64Array, RawExternalInt64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt64Array,
+                         RawExternalInt64Array>(kClassId, data, len, space);
 }
 
 
@@ -12455,13 +12438,11 @@
 
 RawExternalUint64Array* ExternalUint64Array::New(uint64_t* data,
                                                  intptr_t len,
-                                                 void* peer,
-                                                 Dart_PeerFinalizer callback,
                                                  Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_uint64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint64Array, RawExternalUint64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint64Array,
+                         RawExternalUint64Array>(kClassId, data, len, space);
 }
 
 
@@ -12472,13 +12453,11 @@
 
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
-                                                   void* peer,
-                                                   Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_float32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalFloat32Array, RawExternalFloat32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalFloat32Array,
+                         RawExternalFloat32Array>(kClassId, data, len, space);
 }
 
 
@@ -12489,13 +12468,11 @@
 
 RawExternalFloat64Array* ExternalFloat64Array::New(double* data,
                                                    intptr_t len,
-                                                   void* peer,
-                                                   Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_float64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalFloat64Array, RawExternalFloat64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalFloat64Array,
+                         RawExternalFloat64Array>(kClassId, data, len, space);
 }