From ca980662394f11fa298bf686e36e6b3cc28b099f Mon Sep 17 00:00:00 2001 From: Luan Nico Date: Thu, 2 Jan 2025 16:53:19 -0500 Subject: [PATCH 1/4] perf: Enhance performance tests and add insertion_and_removal --- benchmark/comprehensive_benchmark.dart | 201 +++++++++--------- .../insertion_and_removal_benchmark.dart | 36 ++++ benchmark/iteration_benchmark.dart | 4 +- benchmark/main.dart | 2 + 4 files changed, 137 insertions(+), 106 deletions(-) create mode 100644 benchmark/insertion_and_removal_benchmark.dart diff --git a/benchmark/comprehensive_benchmark.dart b/benchmark/comprehensive_benchmark.dart index cb0be15..5cc374b 100644 --- a/benchmark/comprehensive_benchmark.dart +++ b/benchmark/comprehensive_benchmark.dart @@ -4,9 +4,9 @@ import 'package:benchmark_harness/benchmark_harness.dart'; import 'package:ordered_set/comparing.dart'; import 'package:ordered_set/ordered_set.dart'; -const _maxOperations = 2500; +const _maxOperations = 1000; const _maxElement = 10000; -const _startingSetSize = 500; +const _startingSetSize = 250; class ComprehensiveBenchmark extends BenchmarkBase { final Random r; @@ -77,13 +77,13 @@ class _Runtime { while (_queue.isNotEmpty) { final op = _queue.removeAt(0); - op.execute(this, _set).forEach(_queueOp); + op.$1.execute(op, this, _set).forEach(_queueOp); } } void _populateSet() { for (var i = 0; i < _startingSetSize; i++) { - _queueOp(_AddOperation(_randomElement())); + _queueOp((_OperationType.add, _randomElement())); } } @@ -94,27 +94,30 @@ class _Runtime { _Operation _randomOperation() { final type = _OperationType.values[r.nextInt(_OperationType.values.length)]; + const noop = (_OperationType.noop, 0); switch (type) { + case _OperationType.noop: + return noop; case _OperationType.add: - return _AddOperation(_randomElement()); + return (type, _randomElement()); case _OperationType.removeIdx: if (_set.isEmpty) { - return _AddOperation(_randomElement()); + return noop; } - return _RemoveIdxOperation(r.nextInt(_set.length)); + return (type, r.nextInt(_set.length)); case _OperationType.removeElement: if (_set.isEmpty) { - return _AddOperation(_randomElement()); + return noop; } - return _RemoveElementOperation(_set.elementAt(r.nextInt(_set.length))); + return (type, _set.elementAt(r.nextInt(_set.length))); case _OperationType.removeWhere: - return _RemoveWhereOperation(_randomElement()); + return (type, _randomElement()); case _OperationType.visit: - return _VisitOperation(_randomElement()); + return (type, _randomElement()); case _OperationType.iterateThenAdd: - return _IterateThenAddOperation(_randomElement()); + return (type, _randomElement()); case _OperationType.iterateThenRemove: - return _IterateThenRemoveOperation(_randomElement()); + return (type, _randomElement()); } } @@ -122,137 +125,125 @@ class _Runtime { } enum _OperationType { + noop(_noopOperation), // when queued, generates a random element; then adds using `add` - add, + add(_addOperation), // when queued, selects a random index; then removes using `removeAt` - removeIdx, + removeIdx(_removeIdxOperation), // when queued, selects a random element; then removes using `remove` - removeElement, + removeElement(_removeOperation), // when queued, generates a random factor; then removes all elements with // that factor using `removeWhere` - removeWhere, + removeWhere(_removeWhereOperation), // when queued, generates a random factor; then finds the elements matching // that factor, using normal for iteration - visit, + visit(_visitOperation), // when queued, generates two random factors; iterates over the set, //finds elements that match the first factor, then multiplies them by //the second factor, queue adding the results with the `add` operation - iterateThenAdd, + iterateThenAdd(_iterateThenAddOperation), // when queued, generates a random factor; iterates over the set, finding // elements that match the factor, then queue their removal with // the `removeElement` operation - iterateThenRemove, -} - -abstract class _Operation { - final _OperationType type; + iterateThenRemove(_iterateThenRemoveOperation), + ; - const _Operation(this.type); + final List<_Operation> Function(_Operation, _Runtime, OrderedSet) + execute; - List<_Operation> execute(_Runtime runtime, OrderedSet set); + const _OperationType(this.execute); } -class _AddOperation extends _Operation { - final int element; +typedef _Operation = (_OperationType, int); - _AddOperation(this.element) : super(_OperationType.add); - - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - set.add(element); - return []; - } +List<_Operation> _noopOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + return []; } -class _RemoveIdxOperation extends _Operation { - final int index; - - _RemoveIdxOperation(this.index) : super(_OperationType.removeIdx); - - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - if (index < set.length) { - set.removeAt(index); - } - return []; - } +List<_Operation> _addOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + set.add(operation.$2); + return []; } -class _RemoveElementOperation extends _Operation { - final int element; - - _RemoveElementOperation(this.element) : super(_OperationType.removeElement); - - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - set.remove(element); - return []; - } +List<_Operation> _removeOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + set.remove(operation.$2); + return []; } -class _RemoveWhereOperation extends _Operation { - final int factor; - - _RemoveWhereOperation(this.factor) : super(_OperationType.removeWhere); - - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - set.removeWhere((e) => e % factor == 0); +List<_Operation> _removeIdxOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + if (set.isEmpty) { return []; } + set.removeAt(operation.$2); + return []; } -class _VisitOperation extends _Operation { - final int factor; - - _VisitOperation(this.factor) : super(_OperationType.visit); +List<_Operation> _removeWhereOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + set.removeWhere((e) => e % operation.$2 == 0); + return []; +} - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - final output = <_Operation>[]; - for (final e in set) { - if (e % factor == 0) { - output.add(_AddOperation(e * factor)); - } +List<_Operation> _visitOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + final output = <_Operation>[]; + for (final e in set) { + if (e % operation.$2 == 0) { + output.add((_OperationType.add, e * operation.$2)); } - return output; } + return output; } -class _IterateThenAddOperation extends _Operation { - final int factor; - - _IterateThenAddOperation(this.factor) : super(_OperationType.iterateThenAdd); - - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - final toAdd = []; - for (final e in set) { - if (e % factor == 0) { - toAdd.add(e); - } +List<_Operation> _iterateThenAddOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + final toAdd = []; + for (final e in set) { + if (e % operation.$2 == 0) { + toAdd.add(e); } - - return toAdd.map(_AddOperation.new).toList(); } -} -class _IterateThenRemoveOperation extends _Operation { - final int factor; - - _IterateThenRemoveOperation(this.factor) - : super(_OperationType.iterateThenRemove); + return toAdd.map((e) => (_OperationType.add, e)).toList(); +} - @override - List<_Operation> execute(_Runtime runtime, OrderedSet set) { - final toRemove = []; - for (final e in set) { - if (e % factor == 0) { - toRemove.add(e); - } +List<_Operation> _iterateThenRemoveOperation( + _Operation operation, + _Runtime runtime, + OrderedSet set, +) { + final toRemove = []; + for (final e in set) { + if (e % operation.$2 == 0) { + toRemove.add(e); } - return toRemove.map(_RemoveElementOperation.new).toList(); } + return toRemove.map((e) => (_OperationType.removeElement, e)).toList(); } int _countFactors(int initialValue, int factor) { diff --git a/benchmark/insertion_and_removal_benchmark.dart b/benchmark/insertion_and_removal_benchmark.dart new file mode 100644 index 0000000..c23c56e --- /dev/null +++ b/benchmark/insertion_and_removal_benchmark.dart @@ -0,0 +1,36 @@ +import 'package:benchmark_harness/benchmark_harness.dart'; +import 'package:ordered_set/ordered_set.dart'; + +import '../test/comparable_object.dart'; + +const _iterationAmount = 1000; + +class InsertionAndRemovalBenchmark extends BenchmarkBase { + late final OrderedSet set; + late final Map objects; + + InsertionAndRemovalBenchmark() : super('Insertion and Removal Benchmark'); + + static void main() { + InsertionAndRemovalBenchmark().report(); + } + + @override + void setup() { + set = OrderedSet(); + objects = { + for (var i = 0; i < _iterationAmount; i++) i: ComparableObject(i, '$i'), + }; + } + + @override + void exercise() { + for (var i = 0; i < _iterationAmount; i++) { + set.add(objects[i]!); + } + + for (var i = 0; i < _iterationAmount; i++) { + set.remove(objects[i]!); + } + } +} diff --git a/benchmark/iteration_benchmark.dart b/benchmark/iteration_benchmark.dart index be07a9b..c7c0ace 100644 --- a/benchmark/iteration_benchmark.dart +++ b/benchmark/iteration_benchmark.dart @@ -5,6 +5,8 @@ import 'package:ordered_set/ordered_set.dart'; import '../test/comparable_object.dart'; +const _iterationAmount = 1000; + class IterationBenchmark extends BenchmarkBase { late final OrderedSet set; @@ -17,7 +19,7 @@ class IterationBenchmark extends BenchmarkBase { @override void setup() { set = OrderedSet(); - for (var i = 0; i < 1000; i++) { + for (var i = 0; i < _iterationAmount; i++) { final l = (10 + sqrt(i)).floor(); for (var j = 0; j <= l; j++) { set.add(ComparableObject(i, '$i-$j')); diff --git a/benchmark/main.dart b/benchmark/main.dart index f498ab7..4632841 100644 --- a/benchmark/main.dart +++ b/benchmark/main.dart @@ -1,7 +1,9 @@ import 'comprehensive_benchmark.dart'; +import 'insertion_and_removal_benchmark.dart'; import 'iteration_benchmark.dart'; void main() { IterationBenchmark.main(); + InsertionAndRemovalBenchmark.main(); ComprehensiveBenchmark.main(); } From 54c5d57ef5ceb4210e05d64f5090a32d29d4a3c9 Mon Sep 17 00:00:00 2001 From: Luan Nico Date: Fri, 3 Jan 2025 16:48:25 -0500 Subject: [PATCH 2/4] Address comments --- benchmark/comprehensive_benchmark.dart | 258 +++++++++++++++---------- 1 file changed, 155 insertions(+), 103 deletions(-) diff --git a/benchmark/comprehensive_benchmark.dart b/benchmark/comprehensive_benchmark.dart index 5cc374b..e5eb3a8 100644 --- a/benchmark/comprehensive_benchmark.dart +++ b/benchmark/comprehensive_benchmark.dart @@ -96,27 +96,27 @@ class _Runtime { final type = _OperationType.values[r.nextInt(_OperationType.values.length)]; const noop = (_OperationType.noop, 0); switch (type) { - case _OperationType.noop: + case _NoOp(): return noop; - case _OperationType.add: + case _AddOp(): return (type, _randomElement()); - case _OperationType.removeIdx: + case _RemoveIdxOp(): if (_set.isEmpty) { return noop; } return (type, r.nextInt(_set.length)); - case _OperationType.removeElement: + case _RemoveElementOp(): if (_set.isEmpty) { return noop; } return (type, _set.elementAt(r.nextInt(_set.length))); - case _OperationType.removeWhere: + case _RemoveWhereOp(): return (type, _randomElement()); - case _OperationType.visit: + case _VisitOp(): return (type, _randomElement()); - case _OperationType.iterateThenAdd: + case _IterateThenAddOp(): return (type, _randomElement()); - case _OperationType.iterateThenRemove: + case _IterateThenRemoveOp(): return (type, _randomElement()); } } @@ -124,128 +124,180 @@ class _Runtime { int _randomElement() => r.nextInt(_maxElement) + 1; } -enum _OperationType { - noop(_noopOperation), - // when queued, generates a random element; then adds using `add` - add(_addOperation), - // when queued, selects a random index; then removes using `removeAt` - removeIdx(_removeIdxOperation), - // when queued, selects a random element; then removes using `remove` - removeElement(_removeOperation), - // when queued, generates a random factor; then removes all elements with - // that factor using `removeWhere` - removeWhere(_removeWhereOperation), - // when queued, generates a random factor; then finds the elements matching - // that factor, using normal for iteration - visit(_visitOperation), - // when queued, generates two random factors; iterates over the set, - //finds elements that match the first factor, then multiplies them by - //the second factor, queue adding the results with the `add` operation - iterateThenAdd(_iterateThenAddOperation), - // when queued, generates a random factor; iterates over the set, finding - // elements that match the factor, then queue their removal with - // the `removeElement` operation - iterateThenRemove(_iterateThenRemoveOperation), - ; - - final List<_Operation> Function(_Operation, _Runtime, OrderedSet) - execute; - - const _OperationType(this.execute); +sealed class _OperationType { + static const noop = _NoOp(); + static const add = _AddOp(); + static const removeIdx = _RemoveIdxOp(); + static const removeElement = _RemoveElementOp(); + static const removeWhere = _RemoveWhereOp(); + static const visit = _VisitOp(); + static const iterateThenAdd = _IterateThenAddOp(); + static const iterateThenRemove = _IterateThenRemoveOp(); + + static const values = [ + noop, + add, + removeIdx, + removeElement, + removeWhere, + visit, + iterateThenAdd, + iterateThenRemove, + ]; + + const _OperationType(); + + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ); } -typedef _Operation = (_OperationType, int); +/// Just placeholder to return an operation when none is desired. +class _NoOp extends _OperationType { + const _NoOp(); -List<_Operation> _noopOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - return []; + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + return []; + } } -List<_Operation> _addOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - set.add(operation.$2); - return []; +/// When queued, generates a random element; then adds using `add`. +class _AddOp extends _OperationType { + const _AddOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + set.add(operation.$2); + return []; + } } -List<_Operation> _removeOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - set.remove(operation.$2); - return []; +/// When queued, selects a random index; then removes using `removeAt`. +class _RemoveIdxOp extends _OperationType { + const _RemoveIdxOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + if (set.isEmpty) { + return []; + } + set.removeAt(operation.$2); + return []; + } } -List<_Operation> _removeIdxOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - if (set.isEmpty) { +/// When queued, selects a random element; then removes using `remove`. +class _RemoveElementOp extends _OperationType { + const _RemoveElementOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + set.remove(operation.$2); return []; } - set.removeAt(operation.$2); - return []; } -List<_Operation> _removeWhereOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - set.removeWhere((e) => e % operation.$2 == 0); - return []; +/// When queued, generates a random factor; then removes all elements with +/// that factor using `removeWhere`. +class _RemoveWhereOp extends _OperationType { + const _RemoveWhereOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + set.removeWhere((e) => e % operation.$2 == 0); + return []; + } } -List<_Operation> _visitOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - final output = <_Operation>[]; - for (final e in set) { - if (e % operation.$2 == 0) { - output.add((_OperationType.add, e * operation.$2)); +/// When queued, generates a random factor; then finds the elements matching +/// that factor, using normal for iteration. +class _VisitOp extends _OperationType { + const _VisitOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + final output = <_Operation>[]; + for (final e in set) { + if (e % operation.$2 == 0) { + output.add((_OperationType.add, e * operation.$2)); + } } + return output; } - return output; } -List<_Operation> _iterateThenAddOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - final toAdd = []; - for (final e in set) { - if (e % operation.$2 == 0) { - toAdd.add(e); +/// When queued, generates two random factors; iterates over the set, +/// finds elements that match the first factor, then multiplies them by +/// the second factor, queue adding the results with the `add` operation +class _IterateThenAddOp extends _OperationType { + const _IterateThenAddOp(); + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + final output = <_Operation>[]; + for (final e in set) { + if (e % operation.$2 == 0) { + output.add((_OperationType.add, e * operation.$2)); + } } + return output; } - - return toAdd.map((e) => (_OperationType.add, e)).toList(); } -List<_Operation> _iterateThenRemoveOperation( - _Operation operation, - _Runtime runtime, - OrderedSet set, -) { - final toRemove = []; - for (final e in set) { - if (e % operation.$2 == 0) { - toRemove.add(e); +/// When queued, generates a random factor; iterates over the set, finding +/// elements that match the factor, then queue their removal with +/// the `removeElement` operation. +class _IterateThenRemoveOp extends _OperationType { + const _IterateThenRemoveOp(); + + @override + List<_Operation> execute( + _Operation operation, + _Runtime runtime, + OrderedSet set, + ) { + final output = <_Operation>[]; + for (final e in set) { + if (e % operation.$2 == 0) { + output.add((_OperationType.removeElement, e)); + } } + return output; } - return toRemove.map((e) => (_OperationType.removeElement, e)).toList(); } +typedef _Operation = (_OperationType, int); + int _countFactors(int initialValue, int factor) { var count = 0; var value = initialValue; From 9190ba0a1b4bcfa2b31035cc41b8dff7969b7a09 Mon Sep 17 00:00:00 2001 From: Luan Nico Date: Fri, 3 Jan 2025 20:10:53 -0500 Subject: [PATCH 3/4] Use sealed classes instead --- benchmark/comprehensive_benchmark.dart | 90 ++++++++++---------------- 1 file changed, 35 insertions(+), 55 deletions(-) diff --git a/benchmark/comprehensive_benchmark.dart b/benchmark/comprehensive_benchmark.dart index e5eb3a8..e2b3516 100644 --- a/benchmark/comprehensive_benchmark.dart +++ b/benchmark/comprehensive_benchmark.dart @@ -77,13 +77,13 @@ class _Runtime { while (_queue.isNotEmpty) { final op = _queue.removeAt(0); - op.$1.execute(op, this, _set).forEach(_queueOp); + op.execute(this, _set).forEach(_queueOp); } } void _populateSet() { for (var i = 0; i < _startingSetSize; i++) { - _queueOp((_OperationType.add, _randomElement())); + _queueOp(_OperationType.add.create(_randomElement())); } } @@ -93,39 +93,25 @@ class _Runtime { } _Operation _randomOperation() { - final type = _OperationType.values[r.nextInt(_OperationType.values.length)]; - const noop = (_OperationType.noop, 0); - switch (type) { - case _NoOp(): - return noop; - case _AddOp(): - return (type, _randomElement()); - case _RemoveIdxOp(): - if (_set.isEmpty) { - return noop; - } - return (type, r.nextInt(_set.length)); - case _RemoveElementOp(): - if (_set.isEmpty) { - return noop; - } - return (type, _set.elementAt(r.nextInt(_set.length))); - case _RemoveWhereOp(): - return (type, _randomElement()); - case _VisitOp(): - return (type, _randomElement()); - case _IterateThenAddOp(): - return (type, _randomElement()); - case _IterateThenRemoveOp(): - return (type, _randomElement()); - } + final type = _set.isEmpty + ? _OperationType.add + : _OperationType.values[r.nextInt(_OperationType.values.length)]; + final value = switch (type) { + _AddOp() => _randomElement(), + _RemoveIdxOp() => r.nextInt(_set.length), + _RemoveElementOp() => _set.elementAt(r.nextInt(_set.length)), + _RemoveWhereOp() => _randomElement(), + _VisitOp() => _randomElement(), + _IterateThenAddOp() => _randomElement(), + _IterateThenRemoveOp() => _randomElement(), + }; + return type.create(value); } int _randomElement() => r.nextInt(_maxElement) + 1; } sealed class _OperationType { - static const noop = _NoOp(); static const add = _AddOp(); static const removeIdx = _RemoveIdxOp(); static const removeElement = _RemoveElementOp(); @@ -135,7 +121,6 @@ sealed class _OperationType { static const iterateThenRemove = _IterateThenRemoveOp(); static const values = [ - noop, add, removeIdx, removeElement, @@ -147,25 +132,13 @@ sealed class _OperationType { const _OperationType(); - List<_Operation> execute( - _Operation operation, - _Runtime runtime, - OrderedSet set, - ); -} + _Operation create(int factor) => (type: this, value: factor); -/// Just placeholder to return an operation when none is desired. -class _NoOp extends _OperationType { - const _NoOp(); - - @override List<_Operation> execute( _Operation operation, _Runtime runtime, OrderedSet set, - ) { - return []; - } + ); } /// When queued, generates a random element; then adds using `add`. @@ -178,7 +151,7 @@ class _AddOp extends _OperationType { _Runtime runtime, OrderedSet set, ) { - set.add(operation.$2); + set.add(operation.value); return []; } } @@ -196,7 +169,7 @@ class _RemoveIdxOp extends _OperationType { if (set.isEmpty) { return []; } - set.removeAt(operation.$2); + set.removeAt(operation.value); return []; } } @@ -211,7 +184,7 @@ class _RemoveElementOp extends _OperationType { _Runtime runtime, OrderedSet set, ) { - set.remove(operation.$2); + set.remove(operation.value); return []; } } @@ -227,7 +200,7 @@ class _RemoveWhereOp extends _OperationType { _Runtime runtime, OrderedSet set, ) { - set.removeWhere((e) => e % operation.$2 == 0); + set.removeWhere((e) => e % operation.value == 0); return []; } } @@ -245,8 +218,8 @@ class _VisitOp extends _OperationType { ) { final output = <_Operation>[]; for (final e in set) { - if (e % operation.$2 == 0) { - output.add((_OperationType.add, e * operation.$2)); + if (e % operation.value == 0) { + output.add(_OperationType.add.create(e * operation.value)); } } return output; @@ -258,6 +231,7 @@ class _VisitOp extends _OperationType { /// the second factor, queue adding the results with the `add` operation class _IterateThenAddOp extends _OperationType { const _IterateThenAddOp(); + @override List<_Operation> execute( _Operation operation, @@ -266,8 +240,8 @@ class _IterateThenAddOp extends _OperationType { ) { final output = <_Operation>[]; for (final e in set) { - if (e % operation.$2 == 0) { - output.add((_OperationType.add, e * operation.$2)); + if (e % operation.value == 0) { + output.add(_OperationType.add.create(e * operation.value)); } } return output; @@ -288,15 +262,21 @@ class _IterateThenRemoveOp extends _OperationType { ) { final output = <_Operation>[]; for (final e in set) { - if (e % operation.$2 == 0) { - output.add((_OperationType.removeElement, e)); + if (e % operation.value == 0) { + output.add(_OperationType.removeElement.create(e)); } } return output; } } -typedef _Operation = (_OperationType, int); +typedef _Operation = ({_OperationType type, int value}); + +extension on _Operation { + List<_Operation> execute(_Runtime runtime, OrderedSet set) { + return type.execute(this, runtime, set); + } +} int _countFactors(int initialValue, int factor) { var count = 0; From 6f758273929fdd560b4e8bfe4bf77f19f0210bf7 Mon Sep 17 00:00:00 2001 From: Luan Nico Date: Fri, 3 Jan 2025 20:13:08 -0500 Subject: [PATCH 4/4] Formatting --- .github/workflows/benchmark.yml | 2 +- benchmark/comprehensive_benchmark.dart | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 95ed812..391554c 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -11,7 +11,7 @@ jobs: - uses: dart-lang/setup-dart@v1 - run: dart pub get - - uses: luanpotter/dart-benchmark-action@v0.1.10 + - uses: luanpotter/dart-benchmark-action@v0.1.11 with: paths: "." ignore-tag: "no-benchmark" diff --git a/benchmark/comprehensive_benchmark.dart b/benchmark/comprehensive_benchmark.dart index e2b3516..bb1929f 100644 --- a/benchmark/comprehensive_benchmark.dart +++ b/benchmark/comprehensive_benchmark.dart @@ -94,8 +94,8 @@ class _Runtime { _Operation _randomOperation() { final type = _set.isEmpty - ? _OperationType.add - : _OperationType.values[r.nextInt(_OperationType.values.length)]; + ? _OperationType.add + : _OperationType.values[r.nextInt(_OperationType.values.length)]; final value = switch (type) { _AddOp() => _randomElement(), _RemoveIdxOp() => r.nextInt(_set.length),