| // Copyright (c) 2019, 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(37581): Generate this file. |
| |
| // These micro benchmarks track the speed of reading and writing C memory from |
| // Dart with a specific marshalling and unmarshalling of data. |
| |
| // @dart=2.9 |
| |
| import 'dart:ffi'; |
| import 'dart:io'; |
| |
| import 'package:ffi/ffi.dart'; |
| import 'package:benchmark_harness/benchmark_harness.dart'; |
| |
| import 'dlopen_helper.dart'; |
| |
| // Number of benchmark iterations per function. |
| const N = 1000; |
| |
| // The native library that holds all the native functions being called. |
| DynamicLibrary ffiTestFunctions = dlopenPlatformSpecific('native_functions', |
| path: Platform.script.resolve('../native/out/').path); |
| |
| // |
| // Native types and their Dart counterparts. |
| // |
| |
| typedef NativeFunction1Uint8 = Uint8 Function(Uint8); |
| typedef NativeFunction1Uint16 = Uint16 Function(Uint16); |
| typedef NativeFunction1Uint32 = Uint32 Function(Uint32); |
| typedef NativeFunction1Uint64 = Uint64 Function(Uint64); |
| typedef NativeFunction1Int8 = Int8 Function(Int8); |
| typedef NativeFunction1Int16 = Int16 Function(Int16); |
| typedef NativeFunction1Int32 = Int32 Function(Int32); |
| typedef NativeFunction1Int64 = Int64 Function(Int64); |
| typedef Function1int = int Function(int); |
| |
| typedef NativeFunction2Int32 = Int32 Function(Int32, Int32); |
| typedef NativeFunction2Int64 = Int64 Function(Int64, Int64); |
| typedef Function2int = int Function(int, int); |
| |
| typedef NativeFunction4Int32 = Int32 Function(Int32, Int32, Int32, Int32); |
| typedef NativeFunction4Int64 = Int64 Function(Int64, Int64, Int64, Int64); |
| typedef Function4int = int Function(int, int, int, int); |
| |
| typedef NativeFunction10Int32 = Int32 Function( |
| Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32); |
| typedef NativeFunction10Int64 = Int64 Function( |
| Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64); |
| typedef Function10int = int Function( |
| int, int, int, int, int, int, int, int, int, int); |
| |
| typedef NativeFunction20Int32 = Int32 Function( |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32); |
| typedef NativeFunction20Int64 = Int64 Function( |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64, |
| Int64); |
| typedef Function20int = int Function(int, int, int, int, int, int, int, int, |
| int, int, int, int, int, int, int, int, int, int, int, int); |
| |
| typedef NativeFunction1Float = Float Function(Float); |
| typedef NativeFunction1Double = Double Function(Double); |
| typedef Function1double = double Function(double); |
| |
| typedef NativeFunction2Float = Float Function(Float, Float); |
| typedef NativeFunction2Double = Double Function(Double, Double); |
| typedef Function2double = double Function(double, double); |
| |
| typedef NativeFunction4Float = Float Function(Float, Float, Float, Float); |
| typedef NativeFunction4Double = Double Function(Double, Double, Double, Double); |
| typedef Function4double = double Function(double, double, double, double); |
| |
| typedef NativeFunction10Float = Float Function( |
| Float, Float, Float, Float, Float, Float, Float, Float, Float, Float); |
| typedef NativeFunction10Double = Double Function(Double, Double, Double, Double, |
| Double, Double, Double, Double, Double, Double); |
| typedef Function10double = double Function(double, double, double, double, |
| double, double, double, double, double, double); |
| |
| typedef NativeFunction20Float = Float Function( |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float, |
| Float); |
| typedef NativeFunction20Double = Double Function( |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double); |
| typedef Function20double = double Function( |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double, |
| double); |
| |
| typedef Function1PointerUint8 = Pointer<Uint8> Function(Pointer<Uint8>); |
| |
| typedef Function2PointerUint8 = Pointer<Uint8> Function( |
| Pointer<Uint8>, Pointer<Uint8>); |
| |
| typedef Function4PointerUint8 = Pointer<Uint8> Function( |
| Pointer<Uint8>, Pointer<Uint8>, Pointer<Uint8>, Pointer<Uint8>); |
| |
| typedef Function10PointerUint8 = Pointer<Uint8> Function( |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>); |
| |
| typedef Function20PointerUint8 = Pointer<Uint8> Function( |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>, |
| Pointer<Uint8>); |
| |
| typedef NativeFunction1Handle = Handle Function(Handle); |
| typedef Function1Object = Object Function(Object); |
| |
| typedef NativeFunction2Handle = Handle Function(Handle, Handle); |
| typedef Function2Object = Object Function(Object, Object); |
| |
| typedef NativeFunction4Handle = Handle Function(Handle, Handle, Handle, Handle); |
| typedef Function4Object = Object Function(Object, Object, Object, Object); |
| |
| typedef NativeFunction10Handle = Handle Function(Handle, Handle, Handle, Handle, |
| Handle, Handle, Handle, Handle, Handle, Handle); |
| typedef Function10Object = Object Function(Object, Object, Object, Object, |
| Object, Object, Object, Object, Object, Object); |
| |
| typedef NativeFunction20Handle = Handle Function( |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle, |
| Handle); |
| typedef Function20Object = Object Function( |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object, |
| Object); |
| |
| // |
| // Benchmark fixtures. |
| // |
| |
| abstract class FfiBenchmarkBase extends BenchmarkBase { |
| final bool isLeaf; |
| |
| FfiBenchmarkBase(String name, {this.isLeaf: false}) |
| : super('$name${isLeaf ? 'Leaf' : ''}'); |
| |
| void expectEquals(actual, expected) { |
| if (actual != expected) { |
| throw Exception('$name: Unexpected result: $actual, expected $expected'); |
| } |
| } |
| |
| void expectApprox(actual, expected) { |
| if (0.999 * expected > actual || actual > 1.001 * expected) { |
| throw Exception('$name: Unexpected result: $actual, expected $expected'); |
| } |
| } |
| |
| void expectIdentical(actual, expected) { |
| if (!identical(actual, expected)) { |
| throw Exception('$name: Unexpected result: $actual, expected $expected'); |
| } |
| } |
| } |
| |
| class Uint8x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Uint8x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Uint8, |
| Function1int>('Function1Uint8', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Uint8, |
| Function1int>('Function1Uint8', isLeaf: false), |
| super('FfiCall.Uint8x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(17); |
| } |
| expectEquals(x, N * 17 + N * 42); |
| } |
| } |
| |
| class Uint16x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Uint16x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Uint16, |
| Function1int>('Function1Uint16', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Uint16, |
| Function1int>('Function1Uint16', isLeaf: false), |
| super('FfiCall.Uint16x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(17); |
| } |
| expectEquals(x, N * (17 + 42)); |
| } |
| } |
| |
| class Uint32x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Uint32x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Uint32, |
| Function1int>('Function1Uint32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Uint32, |
| Function1int>('Function1Uint32', isLeaf: false), |
| super('FfiCall.Uint32x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i); |
| } |
| expectEquals(x, N * (N - 1) / 2 + N * 42); |
| } |
| } |
| |
| class Uint64x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Uint64x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Uint64, |
| Function1int>('Function1Uint64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Uint64, |
| Function1int>('Function1Uint64', isLeaf: false), |
| super('FfiCall.Uint64x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i); |
| } |
| expectEquals(x, N * (N - 1) / 2 + N * 42); |
| } |
| } |
| |
| class Int8x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Int8x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Int8, |
| Function1int>('Function1Int8', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Int8, |
| Function1int>('Function1Int8', isLeaf: false), |
| super('FfiCall.Int8x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(17); |
| } |
| expectEquals(x, N * (17 + 42)); |
| } |
| } |
| |
| class Int16x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Int16x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Int16, |
| Function1int>('Function1Int16', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Int16, |
| Function1int>('Function1Int16', isLeaf: false), |
| super('FfiCall.Int16x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(17); |
| } |
| expectEquals(x, N * (17 + 42)); |
| } |
| } |
| |
| class Int32x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Int32x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Int32, |
| Function1int>('Function1Int32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Int32, |
| Function1int>('Function1Int32', isLeaf: false), |
| super('FfiCall.Int32x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i); |
| } |
| expectEquals(x, N * (N - 1) / 2 + N * 42); |
| } |
| } |
| |
| class Int32x02 extends FfiBenchmarkBase { |
| final Function2int f; |
| |
| Int32x02({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction2Int32, |
| Function2int>('Function2Int32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction2Int32, |
| Function2int>('Function2Int32', isLeaf: false), |
| super('FfiCall.Int32x02', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i); |
| } |
| expectEquals(x, N * (N - 1) * 2 / 2); |
| } |
| } |
| |
| class Int32x04 extends FfiBenchmarkBase { |
| final Function4int f; |
| |
| Int32x04({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction4Int32, |
| Function4int>('Function4Int32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction4Int32, |
| Function4int>('Function4Int32', isLeaf: false), |
| super('FfiCall.Int32x04', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 4 / 2); |
| } |
| } |
| |
| class Int32x10 extends FfiBenchmarkBase { |
| final Function10int f; |
| |
| Int32x10({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction10Int32, |
| Function10int>('Function10Int32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction10Int32, |
| Function10int>('Function10Int32', isLeaf: false), |
| super('FfiCall.Int32x10', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i, i, i, i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 10 / 2); |
| } |
| } |
| |
| class Int32x20 extends FfiBenchmarkBase { |
| final Function20int f; |
| |
| Int32x20({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction20Int32, |
| Function20int>('Function20Int32', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction20Int32, |
| Function20int>('Function20Int32', isLeaf: false), |
| super('FfiCall.Int32x20', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 20 / 2); |
| } |
| } |
| |
| class Int64x01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Int64x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Int64, |
| Function1int>('Function1Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Int64, |
| Function1int>('Function1Int64', isLeaf: false), |
| super('FfiCall.Int64x01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i); |
| } |
| expectEquals(x, N * (N - 1) / 2 + N * 42); |
| } |
| } |
| |
| class Int64x02 extends FfiBenchmarkBase { |
| final Function2int f; |
| |
| Int64x02({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction2Int64, |
| Function2int>('Function2Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction2Int64, |
| Function2int>('Function2Int64', isLeaf: false), |
| super('FfiCall.Int64x02', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i); |
| } |
| expectEquals(x, N * (N - 1) * 2 / 2); |
| } |
| } |
| |
| class Int64x04 extends FfiBenchmarkBase { |
| final Function4int f; |
| |
| Int64x04({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction4Int64, |
| Function4int>('Function4Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction4Int64, |
| Function4int>('Function4Int64', isLeaf: false), |
| super('FfiCall.Int64x04', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 4 / 2); |
| } |
| } |
| |
| class Int64x10 extends FfiBenchmarkBase { |
| final Function10int f; |
| |
| Int64x10({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction10Int64, |
| Function10int>('Function10Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction10Int64, |
| Function10int>('Function10Int64', isLeaf: false), |
| super('FfiCall.Int64x10', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i, i, i, i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 10 / 2); |
| } |
| } |
| |
| class Int64x20 extends FfiBenchmarkBase { |
| final Function20int f; |
| |
| Int64x20({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction20Int64, |
| Function20int>('Function20Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction20Int64, |
| Function20int>('Function20Int64', isLeaf: false), |
| super('FfiCall.Int64x20', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i); |
| } |
| expectEquals(x, N * (N - 1) * 20 / 2); |
| } |
| } |
| |
| class Int64Mintx01 extends FfiBenchmarkBase { |
| final Function1int f; |
| |
| Int64Mintx01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Int64, |
| Function1int>('Function1Int64', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Int64, |
| Function1int>('Function1Int64', isLeaf: false), |
| super('FfiCall.Int64Mintx01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| int x = 0x7FFFFFFF00000000; |
| for (int i = 0; i < N; i++) { |
| x = f(x); |
| } |
| expectEquals(x, 0x7FFFFFFF00000000 + N * 42); |
| } |
| } |
| |
| class Floatx01 extends FfiBenchmarkBase { |
| final Function1double f; |
| |
| Floatx01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Float, |
| Function1double>('Function1Float', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Float, |
| Function1double>('Function1Float', isLeaf: false), |
| super('FfiCall.Floatx01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0.0; |
| for (int i = 0; i < N; i++) { |
| x += f(17.0); |
| } |
| expectApprox(x, N * (17.0 + 42.0)); |
| } |
| } |
| |
| class Floatx02 extends FfiBenchmarkBase { |
| final Function2double f; |
| |
| Floatx02({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction2Float, |
| Function2double>('Function2Float', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction2Float, |
| Function2double>('Function2Float', isLeaf: false), |
| super('FfiCall.Floatx02', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0); |
| } |
| expectApprox(x, N * (1.0 + 2.0)); |
| } |
| } |
| |
| class Floatx04 extends FfiBenchmarkBase { |
| final Function4double f; |
| |
| Floatx04({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction4Float, |
| Function4double>('Function4Float', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction4Float, |
| Function4double>('Function4Float', isLeaf: false), |
| super('FfiCall.Floatx04', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0); |
| } |
| final double expected = N * (1.0 + 2.0 + 3.0 + 4.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Floatx10 extends FfiBenchmarkBase { |
| final Function10double f; |
| |
| Floatx10({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction10Float, |
| Function10double>('Function10Float', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction10Float, |
| Function10double>('Function10Float', isLeaf: false), |
| super('FfiCall.Floatx10', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0); |
| } |
| final double expected = |
| N * (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0 + 9.0 + 10.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Floatx20 extends FfiBenchmarkBase { |
| final Function20double f; |
| |
| Floatx20({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction20Float, |
| Function20double>('Function20Float', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction20Float, |
| Function20double>('Function20Float', isLeaf: false), |
| super('FfiCall.Floatx20', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, |
| 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0); |
| } |
| final double expected = N * |
| (1.0 + |
| 2.0 + |
| 3.0 + |
| 4.0 + |
| 5.0 + |
| 6.0 + |
| 7.0 + |
| 8.0 + |
| 9.0 + |
| 10.0 + |
| 11.0 + |
| 12.0 + |
| 13.0 + |
| 14.0 + |
| 15.0 + |
| 16.0 + |
| 17.0 + |
| 18.0 + |
| 19.0 + |
| 20.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Doublex01 extends FfiBenchmarkBase { |
| final Function1double f; |
| |
| Doublex01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction1Double, |
| Function1double>('Function1Double', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction1Double, |
| Function1double>('Function1Double', isLeaf: false), |
| super('FfiCall.Doublex01', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0.0; |
| for (int i = 0; i < N; i++) { |
| x += f(17.0); |
| } |
| final double expected = N * (17.0 + 42.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Doublex02 extends FfiBenchmarkBase { |
| final Function2double f; |
| |
| Doublex02({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction2Double, |
| Function2double>('Function2Double', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction2Double, |
| Function2double>('Function2Double', isLeaf: false), |
| super('FfiCall.Doublex02', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0); |
| } |
| final double expected = N * (1.0 + 2.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Doublex04 extends FfiBenchmarkBase { |
| final Function4double f; |
| |
| Doublex04({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction4Double, |
| Function4double>('Function4Double', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction4Double, |
| Function4double>('Function4Double', isLeaf: false), |
| super('FfiCall.Doublex04', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0); |
| } |
| final double expected = N * (1.0 + 2.0 + 3.0 + 4.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Doublex10 extends FfiBenchmarkBase { |
| final Function10double f; |
| |
| Doublex10({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction10Double, |
| Function10double>('Function10Double', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction10Double, |
| Function10double>('Function10Double', isLeaf: false), |
| super('FfiCall.Doublex10', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0); |
| } |
| final double expected = |
| N * (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0 + 9.0 + 10.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class Doublex20 extends FfiBenchmarkBase { |
| final Function20double f; |
| |
| Doublex20({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<NativeFunction20Double, |
| Function20double>('Function20Double', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<NativeFunction20Double, |
| Function20double>('Function20Double', isLeaf: false), |
| super('FfiCall.Doublex20', isLeaf: isLeaf); |
| |
| @override |
| void run() { |
| double x = 0; |
| for (int i = 0; i < N; i++) { |
| x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, |
| 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0); |
| } |
| final double expected = N * |
| (1.0 + |
| 2.0 + |
| 3.0 + |
| 4.0 + |
| 5.0 + |
| 6.0 + |
| 7.0 + |
| 8.0 + |
| 9.0 + |
| 10.0 + |
| 11.0 + |
| 12.0 + |
| 13.0 + |
| 14.0 + |
| 15.0 + |
| 16.0 + |
| 17.0 + |
| 18.0 + |
| 19.0 + |
| 20.0); |
| expectApprox(x, expected); |
| } |
| } |
| |
| class PointerUint8x01 extends FfiBenchmarkBase { |
| final Function1PointerUint8 f; |
| |
| PointerUint8x01({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<Function1PointerUint8, |
| Function1PointerUint8>('Function1PointerUint8', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<Function1PointerUint8, |
| Function1PointerUint8>('Function1PointerUint8', isLeaf: false), |
| super('FfiCall.PointerUint8x01', isLeaf: isLeaf); |
| |
| Pointer<Uint8> p1; |
| @override |
| void setup() => p1 = calloc(N + 1); |
| @override |
| void teardown() => calloc.free(p1); |
| |
| @override |
| void run() { |
| Pointer<Uint8> x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x); |
| } |
| expectApprox(x.address, p1.address + N); |
| } |
| } |
| |
| class PointerUint8x02 extends FfiBenchmarkBase { |
| final Function2PointerUint8 f; |
| |
| PointerUint8x02({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<Function2PointerUint8, |
| Function2PointerUint8>('Function2PointerUint8', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<Function2PointerUint8, |
| Function2PointerUint8>('Function2PointerUint8', isLeaf: false), |
| super('FfiCall.PointerUint8x02', isLeaf: isLeaf); |
| |
| Pointer<Uint8> p1, p2; |
| |
| @override |
| void setup() { |
| p1 = calloc(N + 1); |
| p2 = p1.elementAt(1); |
| } |
| |
| @override |
| void teardown() { |
| calloc.free(p1); |
| } |
| |
| @override |
| void run() { |
| Pointer<Uint8> x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2); |
| } |
| expectEquals(x.address, p1.address + N * sizeOf<Uint8>()); |
| } |
| } |
| |
| class PointerUint8x04 extends FfiBenchmarkBase { |
| final Function4PointerUint8 f; |
| |
| PointerUint8x04({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<Function4PointerUint8, |
| Function4PointerUint8>('Function4PointerUint8', isLeaf: true) |
| : ffiTestFunctions.lookupFunction<Function4PointerUint8, |
| Function4PointerUint8>('Function4PointerUint8', isLeaf: false), |
| super('FfiCall.PointerUint8x04', isLeaf: isLeaf); |
| |
| Pointer<Uint8> p1, p2, p3, p4; |
| |
| @override |
| void setup() { |
| p1 = calloc(N + 1); |
| p2 = p1.elementAt(1); |
| p3 = p1.elementAt(2); |
| p4 = p1.elementAt(3); |
| } |
| |
| @override |
| void teardown() { |
| calloc.free(p1); |
| } |
| |
| @override |
| void run() { |
| Pointer<Uint8> x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4); |
| } |
| expectEquals(x.address, p1.address + N * sizeOf<Uint8>()); |
| } |
| } |
| |
| class PointerUint8x10 extends FfiBenchmarkBase { |
| final Function10PointerUint8 f; |
| |
| PointerUint8x10({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<Function10PointerUint8, |
| Function10PointerUint8>('Function10PointerUint8', isLeaf: true) |
| : ffiTestFunctions |
| .lookupFunction<Function10PointerUint8, Function10PointerUint8>( |
| 'Function10PointerUint8', |
| isLeaf: false), |
| super('FfiCall.PointerUint8x10', isLeaf: isLeaf); |
| |
| Pointer<Uint8> p1, p2, p3, p4, p5, p6, p7, p8, p9, p10; |
| |
| @override |
| void setup() { |
| p1 = calloc(N + 1); |
| p2 = p1.elementAt(1); |
| p3 = p1.elementAt(2); |
| p4 = p1.elementAt(3); |
| p5 = p1.elementAt(4); |
| p6 = p1.elementAt(5); |
| p7 = p1.elementAt(6); |
| p8 = p1.elementAt(7); |
| p9 = p1.elementAt(8); |
| p10 = p1.elementAt(9); |
| } |
| |
| @override |
| void teardown() { |
| calloc.free(p1); |
| } |
| |
| @override |
| void run() { |
| Pointer<Uint8> x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10); |
| } |
| expectEquals(x.address, p1.address + N * sizeOf<Uint8>()); |
| } |
| } |
| |
| class PointerUint8x20 extends FfiBenchmarkBase { |
| final Function20PointerUint8 f; |
| |
| PointerUint8x20({isLeaf: false}) |
| : f = isLeaf |
| ? ffiTestFunctions.lookupFunction<Function20PointerUint8, |
| Function20PointerUint8>('Function20PointerUint8', isLeaf: true) |
| : ffiTestFunctions |
| .lookupFunction<Function20PointerUint8, Function20PointerUint8>( |
| 'Function20PointerUint8', |
| isLeaf: false), |
| super('FfiCall.PointerUint8x20', isLeaf: isLeaf); |
| |
| Pointer<Uint8> p1, |
| p2, |
| p3, |
| p4, |
| p5, |
| p6, |
| p7, |
| p8, |
| p9, |
| p10, |
| p11, |
| p12, |
| p13, |
| p14, |
| p15, |
| p16, |
| p17, |
| p18, |
| p19, |
| p20; |
| |
| @override |
| void setup() { |
| p1 = calloc(N + 1); |
| p2 = p1.elementAt(1); |
| p3 = p1.elementAt(2); |
| p4 = p1.elementAt(3); |
| p5 = p1.elementAt(4); |
| p6 = p1.elementAt(5); |
| p7 = p1.elementAt(6); |
| p8 = p1.elementAt(7); |
| p9 = p1.elementAt(8); |
| p10 = p1.elementAt(9); |
| p11 = p1.elementAt(10); |
| p12 = p1.elementAt(11); |
| p13 = p1.elementAt(12); |
| p14 = p1.elementAt(13); |
| p15 = p1.elementAt(14); |
| p16 = p1.elementAt(15); |
| p17 = p1.elementAt(16); |
| p18 = p1.elementAt(17); |
| p19 = p1.elementAt(18); |
| p20 = p1.elementAt(19); |
| } |
| |
| @override |
| void teardown() { |
| calloc.free(p1); |
| } |
| |
| @override |
| void run() { |
| Pointer<Uint8> x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, |
| p16, p17, p18, p19, p20); |
| } |
| expectEquals(x.address, p1.address + N * sizeOf<Uint8>()); |
| } |
| } |
| |
| class MyClass { |
| int a; |
| MyClass(this.a); |
| } |
| |
| class Handlex01 extends FfiBenchmarkBase { |
| final Function1Object f; |
| |
| Handlex01() |
| : f = ffiTestFunctions.lookupFunction<NativeFunction1Handle, |
| Function1Object>('Function1Handle', isLeaf: false), |
| super('FfiCall.Handlex01', isLeaf: false); |
| |
| @override |
| void run() { |
| final p1 = MyClass(123); |
| Object x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x); |
| } |
| expectIdentical(x, p1); |
| } |
| } |
| |
| class Handlex02 extends FfiBenchmarkBase { |
| final Function2Object f; |
| |
| Handlex02() |
| : f = ffiTestFunctions.lookupFunction<NativeFunction2Handle, |
| Function2Object>('Function2Handle', isLeaf: false), |
| super('FfiCall.Handlex02', isLeaf: false); |
| |
| @override |
| void run() { |
| final p1 = MyClass(123); |
| final p2 = MyClass(2); |
| Object x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2); |
| } |
| expectIdentical(x, p1); |
| } |
| } |
| |
| class Handlex04 extends FfiBenchmarkBase { |
| final Function4Object f; |
| |
| Handlex04() |
| : f = ffiTestFunctions.lookupFunction<NativeFunction4Handle, |
| Function4Object>('Function4Handle', isLeaf: false), |
| super('FfiCall.Handlex04', isLeaf: false); |
| |
| @override |
| void run() { |
| final p1 = MyClass(123); |
| final p2 = MyClass(2); |
| final p3 = MyClass(3); |
| final p4 = MyClass(4); |
| Object x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4); |
| } |
| expectIdentical(x, p1); |
| } |
| } |
| |
| class Handlex10 extends FfiBenchmarkBase { |
| final Function10Object f; |
| |
| Handlex10() |
| : f = ffiTestFunctions.lookupFunction<NativeFunction10Handle, |
| Function10Object>('Function10Handle', isLeaf: false), |
| super('FfiCall.Handlex10', isLeaf: false); |
| |
| @override |
| void run() { |
| final p1 = MyClass(123); |
| final p2 = MyClass(2); |
| final p3 = MyClass(3); |
| final p4 = MyClass(4); |
| final p5 = MyClass(5); |
| final p6 = MyClass(6); |
| final p7 = MyClass(7); |
| final p8 = MyClass(8); |
| final p9 = MyClass(9); |
| final p10 = MyClass(10); |
| Object x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10); |
| } |
| expectIdentical(x, p1); |
| } |
| } |
| |
| class Handlex20 extends FfiBenchmarkBase { |
| final Function20Object f; |
| |
| Handlex20() |
| : f = ffiTestFunctions.lookupFunction<NativeFunction20Handle, |
| Function20Object>('Function20Handle', isLeaf: false), |
| super('FfiCall.Handlex20', isLeaf: false); |
| |
| @override |
| void run() { |
| final p1 = MyClass(123); |
| final p2 = MyClass(2); |
| final p3 = MyClass(3); |
| final p4 = MyClass(4); |
| final p5 = MyClass(5); |
| final p6 = MyClass(6); |
| final p7 = MyClass(7); |
| final p8 = MyClass(8); |
| final p9 = MyClass(9); |
| final p10 = MyClass(10); |
| final p11 = MyClass(11); |
| final p12 = MyClass(12); |
| final p13 = MyClass(13); |
| final p14 = MyClass(14); |
| final p15 = MyClass(15); |
| final p16 = MyClass(16); |
| final p17 = MyClass(17); |
| final p18 = MyClass(18); |
| final p19 = MyClass(19); |
| final p20 = MyClass(20); |
| Object x = p1; |
| for (int i = 0; i < N; i++) { |
| x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, |
| p16, p17, p18, p19, p20); |
| } |
| expectIdentical(x, p1); |
| } |
| } |
| |
| // |
| // Main driver. |
| // |
| |
| void main() { |
| final benchmarks = [ |
| () => Uint8x01(), |
| () => Uint8x01(isLeaf: true), |
| () => Uint16x01(), |
| () => Uint32x01(), |
| () => Uint64x01(), |
| () => Int8x01(), |
| () => Int8x01(isLeaf: true), |
| () => Int16x01(), |
| () => Int32x01(), |
| () => Int32x02(), |
| () => Int32x04(), |
| () => Int32x10(), |
| () => Int32x20(), |
| () => Int64x01(), |
| () => Int64x02(), |
| () => Int64x04(), |
| () => Int64x10(), |
| () => Int64x20(), |
| () => Int64x20(isLeaf: true), |
| () => Int64Mintx01(), |
| () => Int64Mintx01(isLeaf: true), |
| () => Floatx01(), |
| () => Floatx02(), |
| () => Floatx04(), |
| () => Floatx10(), |
| () => Floatx20(), |
| () => Floatx20(isLeaf: true), |
| () => Doublex01(), |
| () => Doublex02(), |
| () => Doublex04(), |
| () => Doublex10(), |
| () => Doublex20(), |
| () => Doublex20(isLeaf: true), |
| () => PointerUint8x01(), |
| () => PointerUint8x02(), |
| () => PointerUint8x04(), |
| () => PointerUint8x10(), |
| () => PointerUint8x20(), |
| () => PointerUint8x20(isLeaf: true), |
| () => Handlex01(), |
| () => Handlex02(), |
| () => Handlex04(), |
| () => Handlex10(), |
| () => Handlex20(), |
| ]; |
| for (final benchmark in benchmarks) { |
| benchmark().report(); |
| } |
| } |
