Improve performance of functions with dynamic arguments (#345)

* Deprecated functions with dynamic arguments
* Bump version, update changelog

Author: osa1

CHANGELOG.md

@@ -1,3 +1,30 @@
+## 2.2.0-wip
+
+- Performance of functions that take `dynamic` arguments improved.
+- Most of the members that take `dynamic` arguments are deprecated. New members
+  with non-`dynamic` arguments added.
+
+  Deprecated members:
+  - `Matrix4.translate`
+
+    Instead use: `Matrix4.translateByDouble`, `Matrix4.translateByVector3`,
+    `Matrix4.translateByVector4`.
+
+  - `Matrix4.leftTranslate`
+
+    Instead use: `Matrix4.leftTranslateByDouble`,
+    `Matrix4.leftTranslateByVector3`, `Matrix4.leftTranslateByVector4`.
+
+  - `Matrix4.scale`
+
+    Instead use: `Matrix4.scaleByDouble`, `Matrix4.scaleByVector3`,
+    `Matrix4.scaleByVector4`.
+
+  - `Matrix4.scaled`
+
+    Instead use: `Matrix4.scaledByDouble`, `Matrix4.scaledByVector3`,
+    `Matrix4.scaledByVector4`.
+
 ## 2.1.5
 
 - Fixed `operator -()` of Quaternion (Contributed by tlserver)

benchmark/matrix_bench.dart

@@ -2,6 +2,8 @@
 // All rights reserved. Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// ignore_for_file: deprecated_member_use_from_same_package
+
 import 'dart:math' as math;
 import 'dart:typed_data';
 
@@ -321,6 +323,148 @@ class Matrix3TransposeMultiplyBenchmark extends BenchmarkBase {
   }
 }
 
+class Matrix4TranslateByDoubleGenericBenchmark extends BenchmarkBase {
+  Matrix4TranslateByDoubleGenericBenchmark()
+      : super('Matrix4.translateByDoubleGeneric');
+
+  final temp = Matrix4.zero()..setIdentity();
+
+  static void main() {
+    Matrix4TranslateByDoubleGenericBenchmark().report();
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translate(10.0, 20.0, 30.0);
+    }
+  }
+}
+
+class Matrix4TranslateByVector3GenericBenchmark extends BenchmarkBase {
+  Matrix4TranslateByVector3GenericBenchmark()
+      : super('Matrix4.translateByVector3Generic');
+
+  final temp = Matrix4.zero()..setIdentity();
+  final vec = Vector3(10.0, 20.0, 30.0);
+
+  static void main() {
+    Matrix4TranslateByVector3GenericBenchmark().report();
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translate(vec);
+    }
+  }
+}
+
+class Matrix4TranslateByVector4GenericBenchmark extends BenchmarkBase {
+  Matrix4TranslateByVector4GenericBenchmark()
+      : super('Matrix4.translateByVector4Generic');
+
+  final temp = Matrix4.zero()..setIdentity();
+  final vec = Vector4(10.0, 20.0, 30.0, 40.0);
+
+  static void main() {
+    Matrix4TranslateByVector4GenericBenchmark().report();
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translate(vec);
+    }
+  }
+}
+
+class Matrix4TranslateByDoubleBenchmark extends BenchmarkBase {
+  Matrix4TranslateByDoubleBenchmark() : super('Matrix4.translateByDouble');
+
+  final temp = Matrix4.zero()..setIdentity();
+
+  static void main() {
+    Matrix4TranslateByDoubleBenchmark().report();
+  }
+
+  // Call the benchmarked method with random arguments to make sure TFA won't
+  // specialize it based on the arguments passed and wasm-opt won't inline it,
+  // for fair comparison with the generic case.
+  @override
+  void setup() {
+    for (var i = 0; i < 10; i++) {
+      temp.translateByDouble(
+          i.toDouble(), (i * 10).toDouble(), (i * 5).toDouble(), 1.0);
+    }
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translateByDouble(10.0, 20.0, 30.0, 1.0);
+    }
+  }
+}
+
+class Matrix4TranslateByVector3Benchmark extends BenchmarkBase {
+  Matrix4TranslateByVector3Benchmark() : super('Matrix4.translateByVector3');
+
+  final temp = Matrix4.zero()..setIdentity();
+  final vec = Vector3(10.0, 20.0, 30.0);
+
+  static void main() {
+    Matrix4TranslateByVector3Benchmark().report();
+  }
+
+  // Call the benchmarked method with random arguments to make sure TFA won't
+  // specialize it based on the arguments passed and wasm-opt won't inline it,
+  // for fair comparison with the generic case.
+  @override
+  void setup() {
+    for (var i = 0; i < 10; i++) {
+      temp.translateByVector3(
+          Vector3(i.toDouble(), (i * 10).toDouble(), (i * 5).toDouble()));
+    }
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translateByVector3(vec);
+    }
+  }
+}
+
+class Matrix4TranslateByVector4Benchmark extends BenchmarkBase {
+  Matrix4TranslateByVector4Benchmark() : super('Matrix4.translateByVector4');
+
+  final temp = Matrix4.zero()..setIdentity();
+  final vec = Vector4(10.0, 20.0, 30.0, 40.0);
+
+  static void main() {
+    Matrix4TranslateByVector4Benchmark().report();
+  }
+
+  // Call the benchmarked method with random arguments to make sure TFA won't
+  // specialize it based on the arguments passed and wasm-opt won't inline it,
+  // for fair comparison with the generic case.
+  @override
+  void setup() {
+    for (var i = 0; i < 10; i++) {
+      temp.translateByVector4(Vector4(i.toDouble(), (i * 10).toDouble(),
+          (i * 5).toDouble(), (i * 20).toDouble()));
+    }
+  }
+
+  @override
+  void run() {
+    for (var i = 0; i < 100; i++) {
+      temp.translateByVector4(vec);
+    }
+  }
+}
+
 void main() {
   MatrixMultiplyBenchmark.main();
   SIMDMatrixMultiplyBenchmark.main();
@@ -335,4 +479,10 @@ void main() {
   Matrix3TransformVector3Benchmark.main();
   Matrix3TransformVector2Benchmark.main();
   Matrix3TransposeMultiplyBenchmark.main();
+  Matrix4TranslateByDoubleGenericBenchmark.main();
+  Matrix4TranslateByVector3GenericBenchmark.main();
+  Matrix4TranslateByVector4GenericBenchmark.main();
+  Matrix4TranslateByDoubleBenchmark.main();
+  Matrix4TranslateByVector3Benchmark.main();
+  Matrix4TranslateByVector4Benchmark.main();
 }

lib/src/vector_math/matrix2.dart

@@ -215,17 +215,21 @@ class Matrix2 {
   }
 
   /// Returns a new vector or matrix by multiplying this with [arg].
+  @pragma('wasm:prefer-inline')
+  @pragma('vm:prefer-inline')
+  @pragma('dart2js:prefer-inline')
   dynamic operator *(dynamic arg) {
+    final Object result;
     if (arg is double) {
-      return scaled(arg);
-    }
-    if (arg is Vector2) {
-      return transformed(arg);
-    }
-    if (arg is Matrix2) {
-      return multiplied(arg);
+      result = scaled(arg);
+    } else if (arg is Vector2) {
+      result = transformed(arg);
+    } else if (arg is Matrix2) {
+      result = multiplied(arg);
+    } else {
+      throw ArgumentError(arg);
     }
-    throw ArgumentError(arg);
+    return result;
   }
 
   /// Returns new matrix after component wise this + [arg]

lib/src/vector_math/matrix3.dart

@@ -326,17 +326,21 @@ class Matrix3 {
   }
 
   /// Returns a new vector or matrix by multiplying this with [arg].
+  @pragma('wasm:prefer-inline')
+  @pragma('vm:prefer-inline')
+  @pragma('dart2js:prefer-inline')
   dynamic operator *(dynamic arg) {
+    final Object result;
     if (arg is double) {
-      return scaled(arg);
-    }
-    if (arg is Vector3) {
-      return transformed(arg);
-    }
-    if (arg is Matrix3) {
-      return multiplied(arg);
+      result = scaled(arg);
+    } else if (arg is Vector3) {
+      result = transformed(arg);
+    } else if (arg is Matrix3) {
+      result = multiplied(arg);
+    } else {
+      throw ArgumentError(arg);
     }
-    throw ArgumentError(arg);
+    return result;
   }
 
   /// Returns new matrix after component wise this + [arg]