feat(benchmark): add UniversalScenario enum and extend UniversalChainModule to support chain, register, named, override, async scenarios

benchmark_cherrypick/bin/main.dart

@@ -1,58 +1,52 @@
-import 'package:benchmark_cherrypick/benchmarks/register_and_resolve_benchmark.dart';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/chain_singleton_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/chain_factory_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/named_resolve_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/scope_override_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/async_chain_benchmark.dart';
 import 'package:benchmark_cherrypick/di_adapters/cherrypick_adapter.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_chain_module.dart';
 import 'package:args/args.dart';
 import 'dart:io';
 import 'dart:math';
 
 Future<void> main(List<String> args) async {
   final parser = ArgParser()
-    ..addOption('benchmark', abbr: 'b', help: 'Benchmark name (register, chain_singleton, chain_factory, named, override, async_chain, all)', defaultsTo: 'all')
+    ..addOption('chainCount', abbr: 'c', help: 'Comma-separated chainCounts', defaultsTo: '10')
-    ..addOption('chainCount', abbr: 'c', help: 'Comma-separated chainCounts (используется в chain_singleton/factory)', defaultsTo: '100')
+    ..addOption('nestingDepth', abbr: 'd', help: 'Comma-separated depths', defaultsTo: '5')
-    ..addOption('nestingDepth', abbr: 'd', help: 'Comma-separated depths (используется в chain_singleton/factory)', defaultsTo: '100')
+    ..addOption('mode', abbr: 'm', help: 'Mode (singletonStrategy,factoryStrategy,asyncStrategy)', defaultsTo: 'singletonStrategy')
-    ..addOption('repeat', abbr: 'r', help: 'Repeats for each run (statistical run, >=2)', defaultsTo: '5')
+    ..addOption('repeat', abbr: 'r', help: 'Repeats for each run (>=2)', defaultsTo: '2')
-    ..addOption('warmup', abbr: 'w', help: 'Warmup runs before timing', defaultsTo: '2')
+    ..addOption('warmup', abbr: 'w', help: 'Warmup runs', defaultsTo: '1')
     ..addOption('format', abbr: 'f', help: 'Output format (pretty, csv, json)', defaultsTo: 'pretty')
     ..addFlag('help', abbr: 'h', negatable: false, help: 'Show help');
 
   final result = parser.parse(args);
 
   if (result['help'] == true) {
-    print('Dart DI benchmarks');
+    print('UniversalChainBenchmark');
     print(parser.usage);
-    print('\nExamples:\n'
-        '  dart run bin/main.dart --benchmark=chain_singleton --chainCount=10,100 --nestingDepth=5,10 --format=csv\n'
-        '  dart run bin/main.dart --benchmark=named\n'
-        'Extra: --repeat=7 --warmup=3\n');
     return;
   }
 
-  final di = CherrypickDIAdapter();
-
-  final benchmark = result['benchmark'] as String;
-  final format = result['format'] as String;
-
   final chainCounts = _parseIntList(result['chainCount'] as String);
   final nestDepths  = _parseIntList(result['nestingDepth'] as String);
-  final repeats     = int.tryParse(result['repeat'] as String? ?? "") ?? 5;
+  final modeName    = result['mode'] as String;
-  final warmups     = int.tryParse(result['warmup'] as String? ?? "") ?? 2;
+  final mode        = UniversalBindingMode.values.firstWhere(
+    (m) => m.toString().split('.').last == modeName,
+    orElse: () => UniversalBindingMode.singletonStrategy,
+  );
+  final repeats     = int.tryParse(result['repeat'] as String? ?? "") ?? 2;
+  final warmups     = int.tryParse(result['warmup'] as String? ?? "") ?? 1;
+  final format      = result['format'] as String;
 
+  final di = CherrypickDIAdapter();
   final results = <Map<String, dynamic>>[];
+
   void addResult(
     String name,
-    int? chainCount,
+    int chainCount,
-    int? nestingDepth,
+    int nestingDepth,
     List<num> timings,
     int? memoryDiffKb,
     int? deltaPeakKb,
     int? peakRssKb,
   ) {
     timings.sort();
-    
     var mean = timings.reduce((a, b) => a + b) / timings.length;
     var median = timings[timings.length ~/ 2];
     var minVal = timings.first;
@@ -78,8 +72,8 @@ Future<void> main(List<String> args) async {
   Future<void> runAndCollect(
     String name,
     Future<num> Function() fn, {
-    int? chainCount,
+    required int chainCount,
-    int? nestingDepth,
+    required int nestingDepth,
   }) async {
     for (int i = 0; i < warmups; i++) {
       await fn();
@@ -98,44 +92,18 @@ Future<void> main(List<String> args) async {
     addResult(name, chainCount, nestingDepth, timings, memDiffKB, deltaPeakKb, (peakRss/1024).round());
   }
 
-  if (benchmark == 'all' || benchmark == 'register') {
-    await runAndCollect('RegisterAndResolve', () async {
-      return _captureReport(RegisterAndResolveBenchmark(di).report);
-    });
-  }
-  if (benchmark == 'all' || benchmark == 'chain_singleton') {
   for (final c in chainCounts) {
     for (final d in nestDepths) {
-        await runAndCollect('ChainSingleton', () async {
+      await runAndCollect('UniversalChain_$mode', () async {
-          return _captureReport(() => ChainSingletonBenchmark(di,chainCount: c, nestingDepth: d).report());
+        return _captureReport(() => UniversalChainBenchmark(
+          di,
+          chainCount: c,
+          nestingDepth: d,
+          mode: mode,
+        ).report());
       }, chainCount: c, nestingDepth: d);
     }
   }
-  }
-  if (benchmark == 'all' || benchmark == 'chain_factory') {
-    for (final c in chainCounts) {
-      for (final d in nestDepths) {
-        await runAndCollect('ChainFactory', () async {
-          return _captureReport(() => ChainFactoryBenchmark(di, chainCount: c, nestingDepth: d).report());
-        }, chainCount: c, nestingDepth: d);
-      }
-    }
-  }
-  if (benchmark == 'all' || benchmark == 'named') {
-    await runAndCollect('NamedResolve', () async {
-      return _captureReport(NamedResolveBenchmark(di).report);
-    });
-  }
-  if (benchmark == 'all' || benchmark == 'override') {
-    await runAndCollect('ScopeOverride', () async {
-      return _captureReport(ScopeOverrideBenchmark(di).report);
-    });
-  }
-  if (benchmark == 'all' || benchmark == 'async_chain') {
-    await runAndCollect('AsyncChain', () async {
-      return _captureReportAsync(AsyncChainBenchmark(di).report);
-    });
-  }
 
   if (format == 'json') {
     print(_toJson(results));
@@ -155,12 +123,6 @@ Future<num> _captureReport(void Function() fn) async {
   sw.stop();
   return sw.elapsedMicroseconds;
 }
-Future<num> _captureReportAsync(Future<void> Function() fn) async {
-  final sw = Stopwatch()..start();
-  await fn();
-  sw.stop();
-  return sw.elapsedMicroseconds;
-}
 
 String _toPretty(List<Map<String, dynamic>> rows) {
   final keys = [

benchmark_cherrypick/lib/benchmarks/universal_chain_benchmark.dart

@@ -0,0 +1,40 @@
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_cherrypick/di_adapters/di_adapter.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_chain_module.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_service.dart';
+
+class UniversalChainBenchmark extends BenchmarkBase {
+  final DIAdapter di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+
+  UniversalChainBenchmark(
+      this.di, {
+      this.chainCount = 1,
+      this.nestingDepth = 3,
+      this.mode = UniversalBindingMode.singletonStrategy,
+    }) : super(
+          'UniversalChain: $mode. C/D = $chainCount/$nestingDepth',
+        );
+
+  @override
+  void setup() {
+    di.setupModules([
+      UniversalChainModule(
+        chainCount: chainCount,
+        nestingDepth: nestingDepth,
+        bindingMode: mode,
+      ),
+    ]);
+  }
+
+  @override
+  void teardown() => di.teardown();
+
+  @override
+  void run() {
+    final serviceName = '${chainCount}_$nestingDepth';
+    di.resolve<UniversalService>(named: serviceName);
+  }
+}

benchmark_cherrypick/lib/scenarios/universal_chain_module.dart

@@ -0,0 +1,60 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'universal_service.dart';
+
+enum UniversalBindingMode {
+  singletonStrategy,
+  factoryStrategy,
+  asyncStrategy,
+}
+
+class UniversalChainModule extends Module {
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode bindingMode;
+
+  UniversalChainModule({
+    required this.chainCount,
+    required this.nestingDepth,
+    this.bindingMode = UniversalBindingMode.singletonStrategy,
+  });
+
+  @override
+  void builder(Scope currentScope) {
+    for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
+      for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
+        final chain = chainIndex + 1;
+        final level = levelIndex + 1;
+        final prevDepName = '${chain}_${level - 1}';
+        final depName = '${chain}_$level';
+        switch (bindingMode) {
+          case UniversalBindingMode.singletonStrategy:
+            bind<UniversalService>()
+                .toProvide(() => UniversalServiceImpl(
+                  value: depName,
+                  dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName)
+                .singleton();
+            break;
+          case UniversalBindingMode.factoryStrategy:
+            bind<UniversalService>()
+                .toProvide(() => UniversalServiceImpl(
+                  value: depName,
+                  dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName);
+            break;
+          case UniversalBindingMode.asyncStrategy:
+            bind<UniversalService>()
+                .toProvideAsync(() async => UniversalServiceImpl(
+                  value: depName,
+                  dependency: await currentScope.resolveAsync<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName)
+                .singleton();
+            break;
+        }
+      }
+    }
+  }
+}

benchmark_cherrypick/lib/scenarios/universal_service.dart

@@ -0,0 +1,10 @@
+
+abstract class UniversalService {
+  final String value;
+  final UniversalService? dependency;
+  UniversalService({required this.value, this.dependency});
+}
+
+class UniversalServiceImpl extends UniversalService {
+  UniversalServiceImpl({required super.value, super.dependency});
+}