benchmarks/FfiCall/generate_benchmarks.dart - sdk.git - Git at Google

 // Copyright (c) 2023, 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.

 import 'dart:io';

 //
 // Configuration.
 //

 const nativeToDartType = {
   'Int8': 'int',
   'Int16': 'int',
   'Int32': 'int',
   'Int64': 'int',
   'Uint8': 'int',
   'Uint16': 'int',
   'Uint32': 'int',
   'Uint64': 'int',
   'Float': 'double',
   'Double': 'double',
   'Pointer<Uint8>': 'Pointer<Uint8>',
   'Handle': 'Object',
 };

 const generateFor = {
   'Int8': [1],
   'Int16': [1],
   'Int32': [1, 2, 4, 10, 20],
   'Int64': [1, 2, 4, 10, 20],
   'Uint8': [1],
   'Uint16': [1],
   'Uint32': [1],
   'Uint64': [1],
   'Float': [1, 2, 4, 10, 20],
   'Double': [1, 2, 4, 10, 20],
   'Pointer<Uint8>': [1, 2, 4, 10, 20],
   'Handle': [1, 2, 4, 10, 20],
 };

 const allNumbers = [1, 2, 4, 10, 20];

 //
 // Generator.
 //

 void main() {
   final List<String> nativeTypes = nativeToDartType.keys.toList();
   final List<String> dartTypes = nativeToDartType.values.toSet().toList();
   final List<String> nativeIntTypes = nativeTypes.where(isInt).toList();
   final List<String> nativeDoubleTypes = nativeTypes.where(isDouble).toList();
   final List<String> nativePointerTypes = nativeTypes.where(isPointer).toList();
   final List<String> nativeHandleTypes = nativeTypes.where(isHandle).toList();

   final StringBuffer buffer = StringBuffer();
   buffer.write(header);
   generateTypedefs(buffer, 'Function', dartTypes, allNumbers);
   generateTypedefs(buffer, 'NativeFunction', nativeTypes, allNumbers);
   generateBenchmarkInt(buffer, nativeIntTypes);
   generateBenchmarkDouble(buffer, nativeDoubleTypes);
   generateBenchmarkPointer(buffer, nativePointerTypes);
   generateBenchmarkHandle(buffer, nativeHandleTypes);

   final path = Platform.script.resolve('dart/benchmark_generated.dart').path;
   File(path).writeAsStringSync(buffer.toString());
   print(Process.runSync('dart', ['format', path]).stderr);
 }

 const header = '''
 // Copyright (c) 2023, 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.
 //
 // This file has been automatically generated. Please do not edit it manually.
 // To regenerate the file, run the following script:
 //
 // > dart benchmarks/FfiCall/generate_benchmarks.dart

 // Using part of, so that the library uri is identical to the main file.
 // That way the FfiNativeResolver works for the main uri.
 part of 'FfiCall.dart';

 ''';

 void generateTypedefs(StringBuffer buffer, String namePrefix,
     List<String> types, List<int> numbers) {
   for (String type in types) {
     for (int number in numbers) {
       final String name = '$namePrefix$number${toIdentifier(type)}';
       final String arguments = repeat(type, number, ', ');
       buffer.write('typedef $name = $type Function($arguments);');
     }
   }
 }

 void generateBenchmarkInt(StringBuffer buffer, List<String> types) {
   for (String type in types) {
     final String typeName = toIdentifier(type);
     final String dartType = toIdentifier(nativeToDartType[type]!);
     for (int number in generateFor[type]!) {
       final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
       final String expected = IntVariation(type, number).expectedValue(number);
       final String functionType = 'Function$number$dartType';
       final String functionNativeType = 'NativeFunction$number$typeName';
       final String functionNameC = 'Function$number$typeName';
       final String argument = IntVariation(type, number).argument;
       final String arguments = repeat(argument, number, ', ');
       final String functionNameDart = 'function$number$typeName';
       final String dartArguments =
           List.generate(number, (i) => '$dartType a$i').join(', ');

       buffer.write('''
 class $name extends FfiBenchmarkBase {
   final $functionType f;

   $name({bool isLeaf = false})
         : f = isLeaf
             ? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
             : ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
         super('FfiCall.$name', isLeaf: isLeaf);

   @override
   void run() {
     int x = 0;
     for (int i = 0; i < N; i++) {
       x += f($arguments);
     }
     expectEquals(x, $expected);
   }
 }
 ''');

       for (bool isLeaf in [false, true]) {
         final leaf = isLeaf ? 'Leaf' : '';
         buffer.write('''
 @Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
 external $dartType $functionNameDart$leaf($dartArguments);

 class ${name}Native$leaf extends FfiBenchmarkBase {
   ${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

   @override
   void run() {
     int x = 0;
     for (int i = 0; i < N; i++) {
       x += $functionNameDart$leaf($arguments);
     }
     expectEquals(x, $expected);
   }
 }
 ''');
       }
     }
   }
 }

 void generateBenchmarkDouble(StringBuffer buffer, List<String> types) {
   for (String type in types) {
     final String typeName = toIdentifier(type);
     final String dartType = toIdentifier(nativeToDartType[type]!);
     for (int number in generateFor[type]!) {
       final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
       final String expected = number == 1
           ? 'N + N * 42.0' // Do work with single arg.
           : 'N * $number * ($number + 1) / 2 '; // The rest sums arguments.
       final String functionType = 'Function$number$dartType';
       final String functionNativeType = 'NativeFunction$number$typeName';
       final String functionNameC = 'Function$number$typeName';
       final List<double> argVals = List.generate(number, (i) => 1.0 * (i + 1));
       final String arguments = argVals.join(', ');
       final String functionNameDart = 'function$number$typeName';
       final String dartArguments =
           List.generate(number, (i) => '$dartType a$i').join(', ');
       buffer.write('''
 class $name extends FfiBenchmarkBase {
   final $functionType f;

   $name({bool isLeaf = false})
         : f = isLeaf
             ? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
             : ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
         super('FfiCall.$name', isLeaf: isLeaf);

   @override
   void run() {
     double x = 0;
     for (int i = 0; i < N; i++) {
       x += f($arguments);
     }
     final double expected = $expected;
     expectApprox(x, expected);
   }
 }
 ''');

       for (bool isLeaf in [false, true]) {
         final leaf = isLeaf ? 'Leaf' : '';
         buffer.write('''
 @Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
 external $dartType $functionNameDart$leaf($dartArguments);

 class ${name}Native$leaf extends FfiBenchmarkBase {
   ${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

   @override
   void run() {
     double x = 0;
     for (int i = 0; i < N; i++) {
       x += $functionNameDart$leaf($arguments);
     }
     final double expected = $expected;
     expectApprox(x, expected);
   }
 }
 ''');
       }
     }
   }
 }

 void generateBenchmarkPointer(StringBuffer buffer, List<String> types) {
   for (String type in types) {
     if (type != 'Pointer<Uint8>') throw Exception('Not implemented for $type.');
     final String typeName = toIdentifier(type);
     final String dartType = nativeToDartType[type]!;
     final String dartTypeName = toIdentifier(dartType);
     for (int number in generateFor[type]!) {
       final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
       final List<String> pointerNames =
           List.generate(number, (i) => 'p${i + 1}');
       final String pointers =
           pointerNames.map((n) => '$type $n = nullptr;').join('\n');
       final String setup = List.generate(
           number - 1, (i) => 'p${i + 2} = p1.elementAt(${i + 1});').join();
       final String functionType = 'Function$number$dartTypeName';
       final String functionNativeType = 'NativeFunction$number$typeName';
       final String functionNameC = 'Function$number$typeName';
       final String arguments = pointerNames.skip(1).join(', ');
       final String functionNameDart = 'function$number$typeName';
       final String dartArguments =
           List.generate(number, (i) => '$dartType a$i').join(', ');
       buffer.write('''
 class $name extends FfiBenchmarkBase {
   final $functionType f;

   $name({bool isLeaf = false})
         : f = isLeaf
             ? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
             : ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
         super('FfiCall.$name', isLeaf: isLeaf);

   $pointers

   @override
   void setup() {
     p1 = calloc(N + 1);
     $setup
   }

   @override
   void teardown() {
     calloc.free(p1);
   }

   @override
   void run() {
   $type x = p1;
     for (int i = 0; i < N; i++) {
       x = f(x, $arguments);
     }
     expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
   }
 }
 ''');

       for (bool isLeaf in [false, true]) {
         final leaf = isLeaf ? 'Leaf' : '';
         buffer.write('''
 @Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
 external $dartType $functionNameDart$leaf($dartArguments);

 class ${name}Native$leaf extends FfiBenchmarkBase {
   ${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

   $pointers

   @override
   void setup() {
     p1 = calloc(N + 1);
     $setup
   }

   @override
   void teardown() {
     calloc.free(p1);
   }

   @override
   void run() {
   $type x = p1;
     for (int i = 0; i < N; i++) {
       x = $functionNameDart$leaf(x, $arguments);
     }
     expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
   }
 }
 ''');
       }
     }
   }
 }

 void generateBenchmarkHandle(StringBuffer buffer, List<String> types) {
   for (String type in types) {
     if (type != 'Handle') throw Exception('Not implemented for $type.');
     final String typeName = toIdentifier(type);
     final String dartType = toIdentifier(nativeToDartType[type]!);
     for (int number in generateFor[type]!) {
       final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
       final String setup =
           List.generate(number + 1, (i) => 'final m$i = MyClass($i);')
               .skip(2)
               .join('\n');
       final String functionType = 'Function$number$dartType';
       final String functionNativeType = 'NativeFunction$number$typeName';
       final String functionNameC = 'Function$number$typeName';
       final String arguments =
           List.generate(number - 1, (i) => 'm${i + 2}').join(', ');
       final String functionNameDart = 'function$number$typeName';
       final String dartArguments =
           List.generate(number, (i) => '$dartType a$i').join(', ');
       buffer.write('''
 class $name extends FfiBenchmarkBase {
   final $functionType f;

   $name()
         : f = ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
         super('FfiCall.$name', isLeaf: false);

   @override
   void run() {
     final m1 = MyClass(123);
     $setup
     Object x = m1;
     for (int i = 0; i < N; i++) {
       x = f(x, $arguments);
     }
     expectIdentical(x, m1);
   }
 }

 @Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: false)
 external $dartType $functionNameDart($dartArguments);

 class ${name}Native extends FfiBenchmarkBase {
   ${name}Native() : super('FfiCall.${name}Native', isLeaf: false);

   @override
   void run() {
     final m1 = MyClass(123);
     $setup
     Object x = m1;
     for (int i = 0; i < N; i++) {
       x = $functionNameDart(x, $arguments);
     }
     expectIdentical(x, m1);
   }
 }
 ''');
     }
   }
 }

 //
 // Benchmark variations.
 //

 class IntVariation {
   /// The argument passed to the C function, the same value is passed if the C
   /// function has multiple parameters.
   final String argument;

   /// The expected value of summation of all return values.
   final String Function(int number) expectedValue;

   /// These benchmarks sum all arguments over all iterations.
   IntVariation.LargeIntManyArguments()
       : argument = 'i',
         expectedValue = ((int number) => 'N * (N - 1) * $number / 2');

   /// Benchmarks with only one argument return 42 added to the argument.
   IntVariation.LargeIntOneArgument()
       : argument = 'i',
         expectedValue = ((int number) => 'N * (N - 1) / 2 + N * 42');

   /// The benchmarks with small ints (`int8_t`, `uint8_t`, etc.) we pass an
   /// arbitrary fixed argument between 0 and 127 to prevent truncation.
   ///
   /// The C function returns 42 added to the argument.
   IntVariation.SmallInt()
       : argument = '17',
         expectedValue = ((int number) => 'N * 17 + N * 42');

   factory IntVariation(String type, int number) {
     if (isSmallInt(type)) {
       return IntVariation.SmallInt();
     }
     if (number == 1) {
       return IntVariation.LargeIntOneArgument();
     }
     return IntVariation.LargeIntManyArguments();
   }
 }

 //
 // Helper functions.
 //

 String toIdentifier(String type) =>
     type.replaceAll('<', '').replaceAll('>', '');

 String repeat(String input, int n, String separator) {
   if (n == 0) {
     return '';
   }

   return (input + separator) * (n - 1) + input;
 }

 bool isInt(String type) => type.startsWith('Int') || type.startsWith('Uint');

 /// True for `int8_t`, `uint8_t`, `int16_t`, and `uint16_t`.
 bool isSmallInt(String type) =>
     isInt(type) && (type.contains('8') || type.contains('16'));

 bool isDouble(String type) =>
     type.startsWith('Float') || type.startsWith('Double');

 bool isPointer(String type) => type.startsWith('Pointer');

 bool isHandle(String type) => type == 'Handle';
	// Copyright (c) 2023, 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.

	import 'dart:io';

	//
	// Configuration.
	//

	const nativeToDartType = {
	'Int8': 'int',
	'Int16': 'int',
	'Int32': 'int',
	'Int64': 'int',
	'Uint8': 'int',
	'Uint16': 'int',
	'Uint32': 'int',
	'Uint64': 'int',
	'Float': 'double',
	'Double': 'double',
	'Pointer<Uint8>': 'Pointer<Uint8>',
	'Handle': 'Object',
	};

	const generateFor = {
	'Int8': [1],
	'Int16': [1],
	'Int32': [1, 2, 4, 10, 20],
	'Int64': [1, 2, 4, 10, 20],
	'Uint8': [1],
	'Uint16': [1],
	'Uint32': [1],
	'Uint64': [1],
	'Float': [1, 2, 4, 10, 20],
	'Double': [1, 2, 4, 10, 20],
	'Pointer<Uint8>': [1, 2, 4, 10, 20],
	'Handle': [1, 2, 4, 10, 20],
	};

	const allNumbers = [1, 2, 4, 10, 20];

	//
	// Generator.
	//

	void main() {
	final List<String> nativeTypes = nativeToDartType.keys.toList();
	final List<String> dartTypes = nativeToDartType.values.toSet().toList();
	final List<String> nativeIntTypes = nativeTypes.where(isInt).toList();
	final List<String> nativeDoubleTypes = nativeTypes.where(isDouble).toList();
	final List<String> nativePointerTypes = nativeTypes.where(isPointer).toList();
	final List<String> nativeHandleTypes = nativeTypes.where(isHandle).toList();

	final StringBuffer buffer = StringBuffer();
	buffer.write(header);
	generateTypedefs(buffer, 'Function', dartTypes, allNumbers);
	generateTypedefs(buffer, 'NativeFunction', nativeTypes, allNumbers);
	generateBenchmarkInt(buffer, nativeIntTypes);
	generateBenchmarkDouble(buffer, nativeDoubleTypes);
	generateBenchmarkPointer(buffer, nativePointerTypes);
	generateBenchmarkHandle(buffer, nativeHandleTypes);

	final path = Platform.script.resolve('dart/benchmark_generated.dart').path;
	File(path).writeAsStringSync(buffer.toString());
	print(Process.runSync('dart', ['format', path]).stderr);
	}

	const header = '''
	// Copyright (c) 2023, 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.
	//
	// This file has been automatically generated. Please do not edit it manually.
	// To regenerate the file, run the following script:
	//
	// > dart benchmarks/FfiCall/generate_benchmarks.dart

	// Using part of, so that the library uri is identical to the main file.
	// That way the FfiNativeResolver works for the main uri.
	part of 'FfiCall.dart';

	''';

	void generateTypedefs(StringBuffer buffer, String namePrefix,
	List<String> types, List<int> numbers) {
	for (String type in types) {
	for (int number in numbers) {
	final String name = '$namePrefix$number${toIdentifier(type)}';
	final String arguments = repeat(type, number, ', ');
	buffer.write('typedef $name = $type Function($arguments);');
	}
	}
	}

	void generateBenchmarkInt(StringBuffer buffer, List<String> types) {
	for (String type in types) {
	final String typeName = toIdentifier(type);
	final String dartType = toIdentifier(nativeToDartType[type]!);
	for (int number in generateFor[type]!) {
	final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
	final String expected = IntVariation(type, number).expectedValue(number);
	final String functionType = 'Function$number$dartType';
	final String functionNativeType = 'NativeFunction$number$typeName';
	final String functionNameC = 'Function$number$typeName';
	final String argument = IntVariation(type, number).argument;
	final String arguments = repeat(argument, number, ', ');
	final String functionNameDart = 'function$number$typeName';
	final String dartArguments =
	List.generate(number, (i) => '$dartType a$i').join(', ');

	buffer.write('''
	class $name extends FfiBenchmarkBase {
	final $functionType f;

	$name({bool isLeaf = false})
	: f = isLeaf
	? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
	: ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
	super('FfiCall.$name', isLeaf: isLeaf);

	@override
	void run() {
	int x = 0;
	for (int i = 0; i < N; i++) {
	x += f($arguments);
	}
	expectEquals(x, $expected);
	}
	}
	''');

	for (bool isLeaf in [false, true]) {
	final leaf = isLeaf ? 'Leaf' : '';
	buffer.write('''
	@Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
	external $dartType $functionNameDart$leaf($dartArguments);

	class ${name}Native$leaf extends FfiBenchmarkBase {
	${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

	@override
	void run() {
	int x = 0;
	for (int i = 0; i < N; i++) {
	x += $functionNameDart$leaf($arguments);
	}
	expectEquals(x, $expected);
	}
	}
	''');
	}
	}
	}
	}

	void generateBenchmarkDouble(StringBuffer buffer, List<String> types) {
	for (String type in types) {
	final String typeName = toIdentifier(type);
	final String dartType = toIdentifier(nativeToDartType[type]!);
	for (int number in generateFor[type]!) {
	final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
	final String expected = number == 1
	? 'N + N * 42.0' // Do work with single arg.
	: 'N * $number * ($number + 1) / 2 '; // The rest sums arguments.
	final String functionType = 'Function$number$dartType';
	final String functionNativeType = 'NativeFunction$number$typeName';
	final String functionNameC = 'Function$number$typeName';
	final List<double> argVals = List.generate(number, (i) => 1.0 * (i + 1));
	final String arguments = argVals.join(', ');
	final String functionNameDart = 'function$number$typeName';
	final String dartArguments =
	List.generate(number, (i) => '$dartType a$i').join(', ');
	buffer.write('''
	class $name extends FfiBenchmarkBase {
	final $functionType f;

	$name({bool isLeaf = false})
	: f = isLeaf
	? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
	: ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
	super('FfiCall.$name', isLeaf: isLeaf);

	@override
	void run() {
	double x = 0;
	for (int i = 0; i < N; i++) {
	x += f($arguments);
	}
	final double expected = $expected;
	expectApprox(x, expected);
	}
	}
	''');

	for (bool isLeaf in [false, true]) {
	final leaf = isLeaf ? 'Leaf' : '';
	buffer.write('''
	@Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
	external $dartType $functionNameDart$leaf($dartArguments);

	class ${name}Native$leaf extends FfiBenchmarkBase {
	${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

	@override
	void run() {
	double x = 0;
	for (int i = 0; i < N; i++) {
	x += $functionNameDart$leaf($arguments);
	}
	final double expected = $expected;
	expectApprox(x, expected);
	}
	}
	''');
	}
	}
	}
	}

	void generateBenchmarkPointer(StringBuffer buffer, List<String> types) {
	for (String type in types) {
	if (type != 'Pointer<Uint8>') throw Exception('Not implemented for $type.');
	final String typeName = toIdentifier(type);
	final String dartType = nativeToDartType[type]!;
	final String dartTypeName = toIdentifier(dartType);
	for (int number in generateFor[type]!) {
	final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
	final List<String> pointerNames =
	List.generate(number, (i) => 'p${i + 1}');
	final String pointers =
	pointerNames.map((n) => '$type $n = nullptr;').join('\n');
	final String setup = List.generate(
	number - 1, (i) => 'p${i + 2} = p1.elementAt(${i + 1});').join();
	final String functionType = 'Function$number$dartTypeName';
	final String functionNativeType = 'NativeFunction$number$typeName';
	final String functionNameC = 'Function$number$typeName';
	final String arguments = pointerNames.skip(1).join(', ');
	final String functionNameDart = 'function$number$typeName';
	final String dartArguments =
	List.generate(number, (i) => '$dartType a$i').join(', ');
	buffer.write('''
	class $name extends FfiBenchmarkBase {
	final $functionType f;

	$name({bool isLeaf = false})
	: f = isLeaf
	? ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: true)
	: ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
	super('FfiCall.$name', isLeaf: isLeaf);

	$pointers

	@override
	void setup() {
	p1 = calloc(N + 1);
	$setup
	}

	@override
	void teardown() {
	calloc.free(p1);
	}

	@override
	void run() {
	$type x = p1;
	for (int i = 0; i < N; i++) {
	x = f(x, $arguments);
	}
	expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
	}
	}
	''');

	for (bool isLeaf in [false, true]) {
	final leaf = isLeaf ? 'Leaf' : '';
	buffer.write('''
	@Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: $isLeaf)
	external $dartType $functionNameDart$leaf($dartArguments);

	class ${name}Native$leaf extends FfiBenchmarkBase {
	${name}Native$leaf() : super('FfiCall.${name}Native', isLeaf: $isLeaf);

	$pointers

	@override
	void setup() {
	p1 = calloc(N + 1);
	$setup
	}

	@override
	void teardown() {
	calloc.free(p1);
	}

	@override
	void run() {
	$type x = p1;
	for (int i = 0; i < N; i++) {
	x = $functionNameDart$leaf(x, $arguments);
	}
	expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
	}
	}
	''');
	}
	}
	}
	}

	void generateBenchmarkHandle(StringBuffer buffer, List<String> types) {
	for (String type in types) {
	if (type != 'Handle') throw Exception('Not implemented for $type.');
	final String typeName = toIdentifier(type);
	final String dartType = toIdentifier(nativeToDartType[type]!);
	for (int number in generateFor[type]!) {
	final String name = '${typeName}x${'$number'.padLeft(2, '0')}';
	final String setup =
	List.generate(number + 1, (i) => 'final m$i = MyClass($i);')
	.skip(2)
	.join('\n');
	final String functionType = 'Function$number$dartType';
	final String functionNativeType = 'NativeFunction$number$typeName';
	final String functionNameC = 'Function$number$typeName';
	final String arguments =
	List.generate(number - 1, (i) => 'm${i + 2}').join(', ');
	final String functionNameDart = 'function$number$typeName';
	final String dartArguments =
	List.generate(number, (i) => '$dartType a$i').join(', ');
	buffer.write('''
	class $name extends FfiBenchmarkBase {
	final $functionType f;

	$name()
	: f = ffiTestFunctions.lookupFunction<$functionNativeType,$functionType>('$functionNameC', isLeaf: false),
	super('FfiCall.$name', isLeaf: false);

	@override
	void run() {
	final m1 = MyClass(123);
	$setup
	Object x = m1;
	for (int i = 0; i < N; i++) {
	x = f(x, $arguments);
	}
	expectIdentical(x, m1);
	}
	}

	@Native<$functionNativeType>(symbol: '$functionNameC', isLeaf: false)
	external $dartType $functionNameDart($dartArguments);

	class ${name}Native extends FfiBenchmarkBase {
	${name}Native() : super('FfiCall.${name}Native', isLeaf: false);

	@override
	void run() {
	final m1 = MyClass(123);
	$setup
	Object x = m1;
	for (int i = 0; i < N; i++) {
	x = $functionNameDart(x, $arguments);
	}
	expectIdentical(x, m1);
	}
	}
	''');
	}
	}
	}

	//
	// Benchmark variations.
	//

	class IntVariation {
	/// The argument passed to the C function, the same value is passed if the C
	/// function has multiple parameters.
	final String argument;

	/// The expected value of summation of all return values.
	final String Function(int number) expectedValue;

	/// These benchmarks sum all arguments over all iterations.
	IntVariation.LargeIntManyArguments()
	: argument = 'i',
	expectedValue = ((int number) => 'N * (N - 1) * $number / 2');

	/// Benchmarks with only one argument return 42 added to the argument.
	IntVariation.LargeIntOneArgument()
	: argument = 'i',
	expectedValue = ((int number) => 'N * (N - 1) / 2 + N * 42');

	/// The benchmarks with small ints (`int8_t`, `uint8_t`, etc.) we pass an
	/// arbitrary fixed argument between 0 and 127 to prevent truncation.
	///
	/// The C function returns 42 added to the argument.
	IntVariation.SmallInt()
	: argument = '17',
	expectedValue = ((int number) => 'N * 17 + N * 42');

	factory IntVariation(String type, int number) {
	if (isSmallInt(type)) {
	return IntVariation.SmallInt();
	}
	if (number == 1) {
	return IntVariation.LargeIntOneArgument();
	}
	return IntVariation.LargeIntManyArguments();
	}
	}

	//
	// Helper functions.
	//

	String toIdentifier(String type) =>
	type.replaceAll('<', '').replaceAll('>', '');

	String repeat(String input, int n, String separator) {
	if (n == 0) {
	return '';
	}

	return (input + separator) * (n - 1) + input;
	}

	bool isInt(String type) => type.startsWith('Int') \|\| type.startsWith('Uint');

	/// True for `int8_t`, `uint8_t`, `int16_t`, and `uint16_t`.
	bool isSmallInt(String type) =>
	isInt(type) && (type.contains('8') \|\| type.contains('16'));

	bool isDouble(String type) =>
	type.startsWith('Float') \|\| type.startsWith('Double');

	bool isPointer(String type) => type.startsWith('Pointer');

	bool isHandle(String type) => type == 'Handle';