Refactor _ByteDataView.[set|get]* methods to improve their performance.

runtime/lib/typed_data.dart

 // 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.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 3150 matching lines @@
   int getInt8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
       throw _newRangeError(byteOffset, length);
     }
     return _typedData._getInt8(_offset + byteOffset);
   }
   void setInt8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
       throw _newRangeError(byteOffset, length);
     }
-    _typedData._setInt8(_offset + byteOffset, _toInt8(value));
+    _typedData._setInt8(_offset + byteOffset, value);
   }
 
   int getUint8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
       throw _newRangeError(byteOffset, length);
     }
     return _typedData._getUint8(_offset + byteOffset);
   }
   void setUint8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
       throw _newRangeError(byteOffset, length);
     }
-    _typedData._setUint8(_offset + byteOffset, _toUint8(value));
+    _typedData._setUint8(_offset + byteOffset, value);
   }
 
   int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
       throw _newRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getInt16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianInt16(result, endian._littleEndian);
+    return _byteSwap16(result).toSigned(16);
   }
   void setInt16(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
       throw _newRangeError(byteOffset + 1, length);
     }
-    var set_value = _toInt16(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianInt16(set_value, endian._littleEndian);
-    }
-    _typedData._setInt16(_offset + byteOffset, set_value);
+    _typedData._setInt16(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap16(value));
   }
 
   int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
       throw _newRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getUint16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianUint16(result, endian._littleEndian);
+    return _byteSwap16(result);
   }
   void setUint16(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 1 >= length) {
       throw _newRangeError(byteOffset + 1, length);
     }
-    var set_value = _toUint16(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianUint16(set_value, endian._littleEndian);
-    }
-    _typedData._setUint16(_offset + byteOffset, set_value);
+    _typedData._setUint16(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap16(value));
   }
 
   int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getInt32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianInt32(result, endian._littleEndian);
+    return _byteSwap32(result).toSigned(32);
   }
   void setInt32(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
-    var set_value = _toInt32(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianInt32(set_value, endian._littleEndian);
-    }
-    _typedData._setInt32(_offset + byteOffset, set_value);
+    _typedData._setInt32(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap32(value));
   }
 
   int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getUint32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianUint32(result, endian._littleEndian);
+    return _byteSwap32(result);
   }
   void setUint32(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
-    var set_value = _toUint32(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianUint32(set_value, endian._littleEndian);
-    }
-    _typedData._setUint32(_offset + byteOffset, set_value);
+    _typedData._setUint32(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap32(value));
   }
 
   int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getInt64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianInt64(result, endian._littleEndian);
+    return _byteSwap64(result).toSigned(64);
   }
   void setInt64(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
-    var set_value = _toInt64(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianInt64(set_value, endian._littleEndian);
-    }
-    _typedData._setInt64(_offset + byteOffset, set_value);
+    _typedData._setInt64(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap64(value));
   }
 
   int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getUint64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianUint64(result, endian._littleEndian);
+    return _byteSwap64(result);
   }
   void setUint64(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
-    var set_value = _toUint64(value);
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianUint64(set_value, endian._littleEndian);
-    }
-    _typedData._setUint64(_offset + byteOffset, set_value);
+    _typedData._setUint64(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value : _byteSwap64(value));
   }
 
   double getFloat32(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getFloat32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianFloat32(result, endian._littleEndian);
+    return _byteSwapFloat32(result);
   }
   void setFloat32(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
-    var set_value = value;
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianFloat32(set_value, endian._littleEndian);
-    }
-    _typedData._setFloat32(_offset + byteOffset, set_value);
+    _typedData._setFloat32(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                  : _byteSwapFloat32(value));
   }
 
   double getFloat64(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getFloat64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
-    return _toEndianFloat64(result, endian._littleEndian);
+    return _byteSwapFloat64(result);
   }
   void setFloat64(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 7 >= length) {
       throw _newRangeError(byteOffset + 7, length);
     }
-    var set_value = value;
-    if (!identical(endian, Endianness.HOST_ENDIAN)) {
-      set_value = _toEndianFloat64(set_value, endian._littleEndian);
-    }
-    _typedData._setFloat64(_offset + byteOffset, set_value);
+    _typedData._setFloat64(_offset + byteOffset,
+        identical(endian, Endianness.HOST_ENDIAN) ? value
+                                                  : _byteSwapFloat64(value));
   }
 
   Float32x4 getFloat32x4(int byteOffset,
                          [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     return _typedData._getFloat32x4(_offset + byteOffset);
   }
   void setFloat32x4(int byteOffset,
                     Float32x4 value,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset + 3 >= length) {
       throw _newRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     _typedData._setFloat32x4(_offset + byteOffset, value);
 
   }
 
-
-  // Internal utility methods.
-
-  static int _toEndianInt16(int host_value, bool little_endian)
-      native "ByteData_ToEndianInt16";
-  static int _toEndianUint16(int host_value, bool little_endian)
-      native "ByteData_ToEndianUint16";
-  static int _toEndianInt32(int host_value, bool little_endian)
-      native "ByteData_ToEndianInt32";
-  static int _toEndianUint32(int host_value, bool little_endian)
-      native "ByteData_ToEndianUint32";
-  static int _toEndianInt64(int host_value, bool little_endian)
-      native "ByteData_ToEndianInt64";
-  static int _toEndianUint64(int host_value, bool little_endian)
-      native "ByteData_ToEndianUint64";
-  static double _toEndianFloat32(double host_value, bool little_endian)
-      native "ByteData_ToEndianFloat32";
-  static double _toEndianFloat64(double host_value, bool little_endian)
-      native "ByteData_ToEndianFloat64";
-
-
   final TypedData _typedData;
   final int _offset;
   final int length;
 }
 
+int _byteSwap16(int value) {
+  return ((value & 0xFF00) >> 8) |
+         ((value & 0x00FF) << 8);
+}
+
+int _byteSwap32(int value) {
+  value = ((value & 0xFF00FF00) >> 8)  | ((value & 0x00FF00FF) << 8);
+  value = ((value & 0xFFFF0000) >> 16) | ((value & 0x0000FFFF) << 16);
+  return value;
+}
+
+int _byteSwap64(int value) {
+  return (_byteSwap32(value) << 32) | _byteSwap32(value >> 32);
+}
+
+final _convU32 = new Uint32List(2);

[Florian Schneider, 2015/01/21 09:34:38]

Once we have allocation sinking for fixed size arrays, we should make these
local variables.

[Vyacheslav Egorov (Google), 2015/01/21 12:17:56]

Our load forwarding only supports forwarding for loads&stores typed in the same
way. Here we have a memory location that is written through one type and loaded
through another type. We don't support this and I am not sure it is worth the
trouble to support it.

In fact I realized: I need to check if we even account for possibility of such
aliasing in our algorithm

+final _convF32 = new Float32List.view(_convU32.buffer);
+final _convF64 = new Float64List.view(_convU32.buffer);
+
+double _byteSwapFloat32(double value) {
+  _convF32[0] = value;

[Florian Schneider, 2015/01/21 09:34:38]

How about making the view a local variable? If everything is inlined here,
allocation sinking should eliminate the overhead completely and produce even
better code.

[Vyacheslav Egorov (Google), 2015/01/21 12:17:56]

See above. We are not powerful enough yet.

+  _convU32[0] = _byteSwap32(_convU32[0]);
+  return _convF32[0];

[Florian Schneider, 2015/01/21 09:34:38]

Does it help to force inline [] and []= on typed data views as well?

[Vyacheslav Egorov (Google), 2015/01/21 12:17:56]

They are inlined here. However if we have polymorphism inside []/[]= - we first
inline polymorphically and then eliminate one possibility - but LICM and GVN are
blocked by redifinitons. We should discuss this separately.

+}
+
+double _byteSwapFloat64(double value) {
+  _convF64[0] = value;

[Florian Schneider, 2015/01/21 09:34:38]

Same for the view object here.

[Vyacheslav Egorov (Google), 2015/01/21 12:17:56]

See above for the reasons why it is global.

+  var lo = _convU32[0];
+  _convU32[0] = _byteSwap32(_convU32[1]);
+  _convU32[1] = _byteSwap32(lo);
+  return _convF64[0];
+}
 
 // Top level utility methods.
 int _toInt(int value, int mask) {
   value &= mask;
   if (value > (mask >> 1)) value -= mask + 1;
   return value;
 }
 
 
 int _toInt8(int value) {
@@ skipping 69 matching lines @@
     return value;
   }
   return object;
 }
 
 
 _newRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   return new RangeError(message);
 }