benchmarks/BigIntParsePrint/dart/BigIntParsePrint.dart - sdk.git - Git at Google

 // 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.

 // ignore_for_file: avoid_function_literals_in_foreach_calls

 import 'package:benchmark_harness/benchmark_harness.dart';
 import 'package:fixnum/fixnum.dart';

 import 'native_version_dummy.dart'
     if (dart.library.js) 'native_version_javascript.dart';

 // Benckmark BigInt and Int64 formatting and parsing.

 // A global sink that is used in the [check] method ensures that the results are
 // not optimized.
 dynamic sink1, sink2;

 void check(bool sink2isEven) {
   if (sink1.codeUnits.last.isEven != sink2isEven) {
     throw StateError('Inconsistent $sink1 vs $sink2');
   }
 }

 // These benchmarks measure digit-throughput for parsing and formatting.
 //
 // Each benchmark targets processing [requiredDigits] decimal digits, spread
 // over a list of input values. This makes the benchmarks for different integer
 // lengths roughly comparable.  The number is chosen so that most benchmarks
 // have very close to this number of digits. It corresponds to nine 4096-bit
 // integers.
 const requiredDigits = 11106;

 class ParseBigIntBenchmark extends BenchmarkBase {
   final int bits;
   final BigInt seed;
   final List<String> strings = [];

   ParseBigIntBenchmark(String name, this.bits)
       : seed = (BigInt.one << bits) - BigInt.one,
         super(name);

   @override
   void setup() {
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (b.bitLength < bits) {
         b = seed;
       }
       final string = b.toString();
       strings.add(string);
       totalLength += string.length;
       b = b - (b >> 8);
     }
   }

   @override
   void run() {
     for (final s in strings) {
       final b = BigInt.parse(s);
       sink1 = s;
       sink2 = b;
     }
     check(sink2.isEven);
   }
 }

 int int64UnsignedBitLength(Int64 i) => i.isNegative ? 64 : i.bitLength;

 class ParseInt64Benchmark extends BenchmarkBase {
   final int bits;
   final Int64 seed;
   final List<String> strings = [];

   ParseInt64Benchmark(String name, this.bits)
       : seed = (Int64.ONE << bits) - Int64.ONE,
         super(name);

   @override
   void setup() {
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (int64UnsignedBitLength(b) < bits) {
         b = seed;
       }
       final string = b.toStringUnsigned();
       strings.add(string);
       totalLength += string.length;
       b = b - b.shiftRightUnsigned(8);
     }
   }

   @override
   void run() {
     for (final s in strings) {
       final b = Int64.parseInt(s);
       sink1 = s;
       sink2 = b;
     }
     check(sink2.isEven);
   }
 }

 class ParseJsBigIntBenchmark extends BenchmarkBase {
   final int bits;
   final Object seed;
   final List<String> strings = [];

   ParseJsBigIntBenchmark(String name, this.bits)
       : seed = nativeBigInt.subtract(
             nativeBigInt.shiftLeft(
                 nativeBigInt.one, nativeBigInt.fromInt(bits)),
             nativeBigInt.one),
         super(name);

   @override
   void setup() {
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (nativeBigInt.bitLength(b) < bits) {
         b = seed;
       }
       final string = nativeBigInt.toStringMethod(b);
       strings.add(string);
       totalLength += string.length;
       b = nativeBigInt.subtract(
           b, nativeBigInt.shiftRight(b, nativeBigInt.eight));
     }
   }

   @override
   void run() {
     for (final s in strings) {
       final b = nativeBigInt.parse(s);
       sink1 = s;
       sink2 = b;
     }
     check(nativeBigInt.isEven(sink2));
   }
 }

 class FormatBigIntBenchmark extends BenchmarkBase {
   final int bits;
   final BigInt seed;
   final List<BigInt> values = [];

   FormatBigIntBenchmark(String name, this.bits)
       : seed = (BigInt.one << bits) - BigInt.one,
         super(name);

   @override
   void setup() {
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (b.bitLength < bits) {
         b = seed;
       }
       final string = b.toString();
       values.add(b - BigInt.one); // We add 'one' back later.
       totalLength += string.length;
       b = b - (b >> 8);
     }
   }

   @override
   void run() {
     final one = BigInt.one;
     for (final b0 in values) {
       // Instances might cache `toString()`, so use arithmetic to create a new
       // instance to try to protect against measuring a cached string.
       final b = b0 + one;
       final s = b.toString();
       sink1 = s;
       sink2 = b;
     }
     check(sink2.isEven);
   }
 }

 class FormatInt64Benchmark extends BenchmarkBase {
   final int bits;
   final Int64 seed;
   final List<Int64> values = [];

   FormatInt64Benchmark(String name, this.bits)
       : seed = (Int64.ONE << bits) - Int64.ONE,
         super(name);

   @override
   void setup() {
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (int64UnsignedBitLength(b) < bits) {
         b = seed;
       }
       final string = b.toStringUnsigned();
       values.add(b - Int64.ONE);
       totalLength += string.length;
       b = b - b.shiftRightUnsigned(8);
     }
   }

   @override
   void run() {
     final one = Int64.ONE;
     for (final b0 in values) {
       // Instances might cache `toString()`, so use arithmetic to create a new
       // instance to try to protect against measuring a cached string.
       final b = b0 + one;
       final s = b.toStringUnsigned();
       sink1 = s;
       sink2 = b;
     }
     check(sink2.isEven);
   }
 }

 class FormatJsBigIntBenchmark extends BenchmarkBase {
   final int bits;
   final Object seed;
   final List<Object> values = [];

   FormatJsBigIntBenchmark(String name, this.bits)
       : seed = nativeBigInt.subtract(
             nativeBigInt.shiftLeft(
                 nativeBigInt.one, nativeBigInt.fromInt(bits)),
             nativeBigInt.one),
         super(name);

   @override
   void setup() {
     final one = nativeBigInt.one;
     var b = seed;
     var totalLength = 0;
     while (totalLength < requiredDigits) {
       if (nativeBigInt.bitLength(b) < bits) {
         b = seed;
       }
       final string = nativeBigInt.toStringMethod(b);
       values.add(nativeBigInt.subtract(b, one)); // We add 'one' back later.
       totalLength += string.length;
       b = nativeBigInt.subtract(
           b, nativeBigInt.shiftRight(b, nativeBigInt.eight));
     }
   }

   @override
   void run() {
     final one = nativeBigInt.one;
     for (final b0 in values) {
       // Instances might cache `toString()`, so use arithmetic to create a new
       // instance to try to protect against measuring a cached string.
       final b = nativeBigInt.add(b0, one);
       final s = nativeBigInt.toStringMethod(b);
       sink1 = s;
       sink2 = b;
     }
     check(nativeBigInt.isEven(sink2));
   }
 }

 /// [DummyBenchmark] instantly returns a fixed 'slow' result.
 class DummyBenchmark extends BenchmarkBase {
   DummyBenchmark(String name) : super(name);
   @override
   double measure() => 2000 * 1000 * 1.0; // A rate of one run per 2s.
 }

 /// Create [ParseJsBigIntBenchmark], or a dummy benchmark if JavaScript BigInt
 /// is not available.  This is to satisfy Golem's constraint that group
 /// benchmarks always produce results for the same set of series.
 BenchmarkBase Function() selectParseNativeBigIntBenchmark(
     String name, int bits) {
   return nativeBigInt.enabled
       ? () => ParseJsBigIntBenchmark(name, bits)
       : () => DummyBenchmark(name);
 }

 /// Create [FormatJsBigIntBenchmark], or a dummy benchmark if JavaScript BigInt
 /// is not available.  This is to satisfy Golem's constraint that group
 /// benchmarks always produce results for the same set of series.
 BenchmarkBase Function() selectFormatNativeBigIntBenchmark(
     String name, int bits) {
   return nativeBigInt.enabled
       ? () => FormatJsBigIntBenchmark(name, bits)
       : () => DummyBenchmark(name);
 }

 void main() {
   final benchmarks = [
     () => ParseInt64Benchmark('Int64.parse.0009.bits', 9),
     () => ParseInt64Benchmark('Int64.parse.0032.bits', 32),
     () => ParseInt64Benchmark('Int64.parse.0064.bits', 64),
     () => ParseBigIntBenchmark('BigInt.parse.0009.bits', 9),
     () => ParseBigIntBenchmark('BigInt.parse.0032.bits', 32),
     () => ParseBigIntBenchmark('BigInt.parse.0064.bits', 64),
     () => ParseBigIntBenchmark('BigInt.parse.0256.bits', 256),
     () => ParseBigIntBenchmark('BigInt.parse.1024.bits', 1024),
     () => ParseBigIntBenchmark('BigInt.parse.4096.bits', 4096),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.0009.bits', 9),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.0032.bits', 32),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.0064.bits', 64),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.0256.bits', 256),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.1024.bits', 1024),
     selectParseNativeBigIntBenchmark('JsBigInt.parse.4096.bits', 4096),
     () => FormatInt64Benchmark('Int64.toString.0009.bits', 9),
     () => FormatInt64Benchmark('Int64.toString.0032.bits', 32),
     () => FormatInt64Benchmark('Int64.toString.0064.bits', 64),
     () => FormatBigIntBenchmark('BigInt.toString.0009.bits', 9),
     () => FormatBigIntBenchmark('BigInt.toString.0032.bits', 32),
     () => FormatBigIntBenchmark('BigInt.toString.0064.bits', 64),
     () => FormatBigIntBenchmark('BigInt.toString.0256.bits', 256),
     () => FormatBigIntBenchmark('BigInt.toString.1024.bits', 1024),
     () => FormatBigIntBenchmark('BigInt.toString.4096.bits', 4096),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.0009.bits', 9),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.0032.bits', 32),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.0064.bits', 64),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.0256.bits', 256),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.1024.bits', 1024),
     selectFormatNativeBigIntBenchmark('JsBigInt.toString.4096.bits', 4096),
   ];

   // Warm up all benchmarks to ensure consistent behavious of shared code.
   benchmarks.forEach((bm) => bm()
     ..setup()
     ..run()
     ..run());

   benchmarks.forEach((bm) => bm().report());
 }
	// 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.

	// ignore_for_file: avoid_function_literals_in_foreach_calls

	import 'package:benchmark_harness/benchmark_harness.dart';
	import 'package:fixnum/fixnum.dart';

	import 'native_version_dummy.dart'
	if (dart.library.js) 'native_version_javascript.dart';

	// Benckmark BigInt and Int64 formatting and parsing.

	// A global sink that is used in the [check] method ensures that the results are
	// not optimized.
	dynamic sink1, sink2;

	void check(bool sink2isEven) {
	if (sink1.codeUnits.last.isEven != sink2isEven) {
	throw StateError('Inconsistent $sink1 vs $sink2');
	}
	}

	// These benchmarks measure digit-throughput for parsing and formatting.
	//
	// Each benchmark targets processing [requiredDigits] decimal digits, spread
	// over a list of input values. This makes the benchmarks for different integer
	// lengths roughly comparable. The number is chosen so that most benchmarks
	// have very close to this number of digits. It corresponds to nine 4096-bit
	// integers.
	const requiredDigits = 11106;

	class ParseBigIntBenchmark extends BenchmarkBase {
	final int bits;
	final BigInt seed;
	final List<String> strings = [];

	ParseBigIntBenchmark(String name, this.bits)
	: seed = (BigInt.one << bits) - BigInt.one,
	super(name);

	@override
	void setup() {
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (b.bitLength < bits) {
	b = seed;
	}
	final string = b.toString();
	strings.add(string);
	totalLength += string.length;
	b = b - (b >> 8);
	}
	}

	@override
	void run() {
	for (final s in strings) {
	final b = BigInt.parse(s);
	sink1 = s;
	sink2 = b;
	}
	check(sink2.isEven);
	}
	}

	int int64UnsignedBitLength(Int64 i) => i.isNegative ? 64 : i.bitLength;

	class ParseInt64Benchmark extends BenchmarkBase {
	final int bits;
	final Int64 seed;
	final List<String> strings = [];

	ParseInt64Benchmark(String name, this.bits)
	: seed = (Int64.ONE << bits) - Int64.ONE,
	super(name);

	@override
	void setup() {
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (int64UnsignedBitLength(b) < bits) {
	b = seed;
	}
	final string = b.toStringUnsigned();
	strings.add(string);
	totalLength += string.length;
	b = b - b.shiftRightUnsigned(8);
	}
	}

	@override
	void run() {
	for (final s in strings) {
	final b = Int64.parseInt(s);
	sink1 = s;
	sink2 = b;
	}
	check(sink2.isEven);
	}
	}

	class ParseJsBigIntBenchmark extends BenchmarkBase {
	final int bits;
	final Object seed;
	final List<String> strings = [];

	ParseJsBigIntBenchmark(String name, this.bits)
	: seed = nativeBigInt.subtract(
	nativeBigInt.shiftLeft(
	nativeBigInt.one, nativeBigInt.fromInt(bits)),
	nativeBigInt.one),
	super(name);

	@override
	void setup() {
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (nativeBigInt.bitLength(b) < bits) {
	b = seed;
	}
	final string = nativeBigInt.toStringMethod(b);
	strings.add(string);
	totalLength += string.length;
	b = nativeBigInt.subtract(
	b, nativeBigInt.shiftRight(b, nativeBigInt.eight));
	}
	}

	@override
	void run() {
	for (final s in strings) {
	final b = nativeBigInt.parse(s);
	sink1 = s;
	sink2 = b;
	}
	check(nativeBigInt.isEven(sink2));
	}
	}

	class FormatBigIntBenchmark extends BenchmarkBase {
	final int bits;
	final BigInt seed;
	final List<BigInt> values = [];

	FormatBigIntBenchmark(String name, this.bits)
	: seed = (BigInt.one << bits) - BigInt.one,
	super(name);

	@override
	void setup() {
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (b.bitLength < bits) {
	b = seed;
	}
	final string = b.toString();
	values.add(b - BigInt.one); // We add 'one' back later.
	totalLength += string.length;
	b = b - (b >> 8);
	}
	}

	@override
	void run() {
	final one = BigInt.one;
	for (final b0 in values) {
	// Instances might cache `toString()`, so use arithmetic to create a new
	// instance to try to protect against measuring a cached string.
	final b = b0 + one;
	final s = b.toString();
	sink1 = s;
	sink2 = b;
	}
	check(sink2.isEven);
	}
	}

	class FormatInt64Benchmark extends BenchmarkBase {
	final int bits;
	final Int64 seed;
	final List<Int64> values = [];

	FormatInt64Benchmark(String name, this.bits)
	: seed = (Int64.ONE << bits) - Int64.ONE,
	super(name);

	@override
	void setup() {
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (int64UnsignedBitLength(b) < bits) {
	b = seed;
	}
	final string = b.toStringUnsigned();
	values.add(b - Int64.ONE);
	totalLength += string.length;
	b = b - b.shiftRightUnsigned(8);
	}
	}

	@override
	void run() {
	final one = Int64.ONE;
	for (final b0 in values) {
	// Instances might cache `toString()`, so use arithmetic to create a new
	// instance to try to protect against measuring a cached string.
	final b = b0 + one;
	final s = b.toStringUnsigned();
	sink1 = s;
	sink2 = b;
	}
	check(sink2.isEven);
	}
	}

	class FormatJsBigIntBenchmark extends BenchmarkBase {
	final int bits;
	final Object seed;
	final List<Object> values = [];

	FormatJsBigIntBenchmark(String name, this.bits)
	: seed = nativeBigInt.subtract(
	nativeBigInt.shiftLeft(
	nativeBigInt.one, nativeBigInt.fromInt(bits)),
	nativeBigInt.one),
	super(name);

	@override
	void setup() {
	final one = nativeBigInt.one;
	var b = seed;
	var totalLength = 0;
	while (totalLength < requiredDigits) {
	if (nativeBigInt.bitLength(b) < bits) {
	b = seed;
	}
	final string = nativeBigInt.toStringMethod(b);
	values.add(nativeBigInt.subtract(b, one)); // We add 'one' back later.
	totalLength += string.length;
	b = nativeBigInt.subtract(
	b, nativeBigInt.shiftRight(b, nativeBigInt.eight));
	}
	}

	@override
	void run() {
	final one = nativeBigInt.one;
	for (final b0 in values) {
	// Instances might cache `toString()`, so use arithmetic to create a new
	// instance to try to protect against measuring a cached string.
	final b = nativeBigInt.add(b0, one);
	final s = nativeBigInt.toStringMethod(b);
	sink1 = s;
	sink2 = b;
	}
	check(nativeBigInt.isEven(sink2));
	}
	}

	/// [DummyBenchmark] instantly returns a fixed 'slow' result.
	class DummyBenchmark extends BenchmarkBase {
	DummyBenchmark(String name) : super(name);
	@override
	double measure() => 2000 * 1000 * 1.0; // A rate of one run per 2s.
	}

	/// Create [ParseJsBigIntBenchmark], or a dummy benchmark if JavaScript BigInt
	/// is not available. This is to satisfy Golem's constraint that group
	/// benchmarks always produce results for the same set of series.
	BenchmarkBase Function() selectParseNativeBigIntBenchmark(
	String name, int bits) {
	return nativeBigInt.enabled
	? () => ParseJsBigIntBenchmark(name, bits)
	: () => DummyBenchmark(name);
	}

	/// Create [FormatJsBigIntBenchmark], or a dummy benchmark if JavaScript BigInt
	/// is not available. This is to satisfy Golem's constraint that group
	/// benchmarks always produce results for the same set of series.
	BenchmarkBase Function() selectFormatNativeBigIntBenchmark(
	String name, int bits) {
	return nativeBigInt.enabled
	? () => FormatJsBigIntBenchmark(name, bits)
	: () => DummyBenchmark(name);
	}

	void main() {
	final benchmarks = [
	() => ParseInt64Benchmark('Int64.parse.0009.bits', 9),
	() => ParseInt64Benchmark('Int64.parse.0032.bits', 32),
	() => ParseInt64Benchmark('Int64.parse.0064.bits', 64),
	() => ParseBigIntBenchmark('BigInt.parse.0009.bits', 9),
	() => ParseBigIntBenchmark('BigInt.parse.0032.bits', 32),
	() => ParseBigIntBenchmark('BigInt.parse.0064.bits', 64),
	() => ParseBigIntBenchmark('BigInt.parse.0256.bits', 256),
	() => ParseBigIntBenchmark('BigInt.parse.1024.bits', 1024),
	() => ParseBigIntBenchmark('BigInt.parse.4096.bits', 4096),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.0009.bits', 9),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.0032.bits', 32),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.0064.bits', 64),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.0256.bits', 256),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.1024.bits', 1024),
	selectParseNativeBigIntBenchmark('JsBigInt.parse.4096.bits', 4096),
	() => FormatInt64Benchmark('Int64.toString.0009.bits', 9),
	() => FormatInt64Benchmark('Int64.toString.0032.bits', 32),
	() => FormatInt64Benchmark('Int64.toString.0064.bits', 64),
	() => FormatBigIntBenchmark('BigInt.toString.0009.bits', 9),
	() => FormatBigIntBenchmark('BigInt.toString.0032.bits', 32),
	() => FormatBigIntBenchmark('BigInt.toString.0064.bits', 64),
	() => FormatBigIntBenchmark('BigInt.toString.0256.bits', 256),
	() => FormatBigIntBenchmark('BigInt.toString.1024.bits', 1024),
	() => FormatBigIntBenchmark('BigInt.toString.4096.bits', 4096),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.0009.bits', 9),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.0032.bits', 32),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.0064.bits', 64),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.0256.bits', 256),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.1024.bits', 1024),
	selectFormatNativeBigIntBenchmark('JsBigInt.toString.4096.bits', 4096),
	];

	// Warm up all benchmarks to ensure consistent behavious of shared code.
	benchmarks.forEach((bm) => bm()
	..setup()
	..run()
	..run());

	benchmarks.forEach((bm) => bm().report());
	}