Merge array allocation and List._copyFromObjectArray to provide fast path for large arrays.

runtime/lib/array.dart

 // 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.
 
 
 // TODO(srdjan): Use shared array implementation.
 class _List<E> implements List<E> {
 
   factory _List(length) native "List_allocate";
 
   E operator [](int index) native "List_getIndexed";
 
   void operator []=(int index, E value) native "List_setIndexed";
 
   String toString() {
     return ListBase.listToString(this);
   }
 
   int get length native "List_getLength";
 
-  void _copyFromObjectArray(_List src,
-                            int srcStart,
-                            int dstStart,
-                            int count) {
-    if (count < 128) {
-      for (int i = 0; i < count; i++) {
-        this[dstStart + i] = src[srcStart + i];
+  List _slice(int start, int count, bool needTypeArgument) {

[srdjan, 2014/09/03 18:08:11]

optional: needsTypeArgument.

[Vyacheslav Egorov (Google), 2014/09/03 20:35:18]

Done.

+    if (count <= 64) {
+      final result = needTypeArgument ? new _List<E>(count)
+                                      : new _List(count);

[srdjan, 2014/09/03 18:08:11]

What is the performance degradation if we always allocate with type argument E?
Or is there a correctness issue?

[Vyacheslav Egorov (Google), 2014/09/03 20:35:18]

I have not measured performance impact. I doubt there is any in unchecked code.
I am just mimicking behavior of the old code in this decision.

+      for (int i = 0; i < result.length; i++) {
+        result[i] = this[start + i];
       }
+      return result;
     } else {
-      _copyFromObjectArrayInternal(src, srcStart, dstStart, count);
+      return _sliceInternal(start, count, needTypeArgument);
     }
   }
 
-  void _copyFromObjectArrayInternal(_List src,
-                                    int srcStart,
-                                    int dstStart,
-                                    int count)
-      native "List_copyFromObjectArray";
+  List _sliceInternal(int start, int count, bool needTypeArgument)
+      native "List_slice";
 
   void insert(int index, E element) {
     throw NonGrowableListError.add();
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     throw NonGrowableListError.add();
   }
 
   void setAll(int index, Iterable<E> iterable) {
@@ skipping 26 matching lines @@
       throw new RangeError.range(start, 0, this.length);
     }
     if (end < start || end > this.length) {
       throw new RangeError.range(end, start, this.length);
     }
     int length = end - start;
     if (length == 0) return;
     if (identical(this, iterable)) {
       Lists.copy(iterable, skipCount, this, start, length);
     } else if (ClassID.getID(iterable) == ClassID.cidArray) {
-      _copyFromObjectArray(iterable, skipCount, start, length);
+      Lists.copy(iterable, skipCount, this, start, length);
     } else if (iterable is List) {
       Lists.copy(iterable, skipCount, this, start, length);
     } else {
       Iterator it = iterable.iterator;
       while (skipCount > 0) {
         if (!it.moveNext()) return;
         skipCount--;
       }
       for (int i = start; i < end; i++) {
         if (!it.moveNext()) return;
@@ skipping 12 matching lines @@
 
   void fillRange(int start, int end, [E fillValue]) {
     IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
   }
 
   List<E> sublist(int start, [int end]) {
     Lists.indicesCheck(this, start, end);
     if (end == null) end = this.length;
     int length = end - start;
     if (start == end) return <E>[];
-    List list = new _List(length);
-    list._copyFromObjectArray(this, start, 0, length);
-    var result = new _GrowableList<E>.withData(list);
+    var result = new _GrowableList<E>.withData(_slice(start, length, false));
     result._setLength(length);
     return result;
   }
 
   // Iterable interface.
 
   bool contains(Object element) {
     return IterableMixinWorkaround.contains(this, element);
   }
 
@@ skipping 130 matching lines @@
 
   E get single {
     if (length == 1) return this[0];
     if (length == 0) throw IterableElementError.noElement();
     throw IterableElementError.tooMany();
   }
 
   List<E> toList({ bool growable: true }) {
     var length = this.length;
     if (length > 0) {
-      var result = growable ? new _List(length) : new _List<E>(length);
-      result._copyFromObjectArray(this, 0, 0, length);
+      var result = _slice(0, length, !growable);
       if (growable) {
         result = new _GrowableList<E>.withData(result);
         result._setLength(length);
       }
       return result;
     }
     // _GrowableList.withData must not be called with empty list.
     return growable ? <E>[] : new List<E>(0);
   }
 
@@ skipping 287 matching lines @@
   bool moveNext() {
     if (_index >= _length) {
       _current = null;
       return false;
     }
     _current = _array[_index];
     _index++;
     return true;
   }
 }