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

// @dart=2.9

import 'dart:collection';
import 'dart:typed_data';
import 'package:benchmark_harness/benchmark_harness.dart';

// Benchmark for polymorphic list copying.
//
// Each benchmark creates a list from an Iterable. There are many slightly
// different ways to do this.
//
// In each benchmark the call site is polymorphic in the input type to simulate
// the behaviour of library methods in the context of a large application. The
// input lists are skewed heavily to the default growable list. This attempts to
// model 'real world' copying of 'ordinary' lists.
//
// The benchmarks are run for small lists (2 elements, names ending in
// `.2`) and 'large' lists (100 elements or `.100`). The benchmarks are
// normalized on the number of elements to make the input sizes comparable.
//
// Most inputs have type `Iterable<num>`, but contain only `int` values. This
// allows is to compare the down-conversion versions of copying where each
// element must be checked.

class Benchmark extends BenchmarkBase {
  final int length;
  final Function() copy;

  final List<Iterable<num>> inputs = [];

  Benchmark(String name, this.length, this.copy)
      : super('ListCopy.$name.$length');

  @override
  void setup() {
    // Ensure setup() is idempotent.
    if (inputs.isNotEmpty) return;
    final List<num> base = List.generate(length, (i) => i + 1);
    List<Iterable<num>> makeVariants() {
      return [
        // Weight ordinary lists more.
        ...List.generate(19, (_) => List<num>.of(base)),

        base.toList(growable: false),
        List<num>.unmodifiable(base),
        UnmodifiableListView(base),
        base.reversed,
        String.fromCharCodes(List<int>.from(base)).codeUnits,
        Uint8List.fromList(List<int>.from(base)),
      ];
    }

    const elements = 10000;
    int totalLength = 0;
    while (totalLength < elements) {
      final variants = makeVariants();
      inputs.addAll(variants);
      totalLength +=
          variants.fold<int>(0, (sum, iterable) => sum + iterable.length);
    }

    // Sanity checks.
    for (var sample in inputs) {
      if (sample.length != length) throw 'Wrong length: $length $sample';
    }
    if (totalLength != elements) {
      throw 'totalLength $totalLength != expected $elements';
    }
  }

  @override
  void run() {
    for (var sample in inputs) {
      input = sample;
      // Unroll loop 10 times to reduce loop overhead, which is about 15% for
      // the fastest short input benchmarks.
      copy();
      copy();
      copy();
      copy();
      copy();
      copy();
      copy();
      copy();
      copy();
      copy();
    }
    if (output.length != inputs.first.length) throw 'Bad result: $output';
  }
}

// All the 'copy' methods use [input] and [output] rather than a parameter and
// return value to avoid any possibility of type check in the call sequence.
Iterable<num> input = const [];
var output;

List<Benchmark> makeBenchmarks(int length) => [
      Benchmark('toList', length, () {
        output = input.toList();
      }),
      Benchmark('toList.fixed', length, () {
        output = input.toList(growable: false);
      }),
      Benchmark('List.of', length, () {
        output = List<num>.of(input);
      }),
      Benchmark('List.of.fixed', length, () {
        output = List<num>.of(input, growable: false);
      }),
      Benchmark('List.num.from', length, () {
        output = List<num>.from(input);
      }),
      Benchmark('List.int.from', length, () {
        output = List<int>.from(input);
      }),
      Benchmark('List.num.from.fixed', length, () {
        output = List<num>.from(input, growable: false);
      }),
      Benchmark('List.int.from.fixed', length, () {
        output = List<int>.from(input, growable: false);
      }),
      Benchmark('List.num.unmodifiable', length, () {
        output = List<num>.unmodifiable(input);
      }),
      Benchmark('List.int.unmodifiable', length, () {
        output = List<int>.unmodifiable(input);
      }),
      Benchmark('spread.num', length, () {
        output = <num>[...input];
      }),
      Benchmark('spread.int', length, () {
        output = <int>[...input];
      }),
      Benchmark('spread.int.cast', length, () {
        output = <int>[...input.cast<int>()];
      }),
      Benchmark('spread.int.map', length, () {
        output = <int>[...input.map((x) => x as int)];
      }),
      Benchmark('for.int', length, () {
        output = <int>[for (var n in input) n as int];
      }),
    ];

void main() {
  final benchmarks = [...makeBenchmarks(2), ...makeBenchmarks(100)];

  // Warmup all benchmarks to ensure JIT compilers see full polymorphism.
  for (var benchmark in benchmarks) {
    benchmark.setup();
  }

  for (var benchmark in benchmarks) {
    benchmark.warmup();
  }

  for (var benchmark in benchmarks) {
    // `report` calls `setup`, but `setup` is idempotent.
    benchmark.report();
  }
}