refactor(benchmark): clean up UniversalChainBenchmark, remove async logic, keep only sync scenario logic

benchmark_cherrypick/bin/main.dart

@@ -1,15 +1,59 @@
 import 'package:benchmark_cherrypick/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_async_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';
 
+enum UniversalBenchmark {
+  registerSingleton,
+  chainSingleton,
+  chainFactory,
+  chainAsync,
+  named,
+  override,
+}
+
+UniversalScenario _toScenario(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalScenario.register;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainFactory:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainAsync:
+      return UniversalScenario.asyncChain;
+    case UniversalBenchmark.named:
+      return UniversalScenario.named;
+    case UniversalBenchmark.override:
+      return UniversalScenario.override;
+  }
+}
+
+UniversalBindingMode _toMode(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainFactory:
+      return UniversalBindingMode.factoryStrategy;
+    case UniversalBenchmark.chainAsync:
+      return UniversalBindingMode.asyncStrategy;
+    case UniversalBenchmark.named:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.override:
+      return UniversalBindingMode.singletonStrategy;
+  }
+}
+
 Future<void> main(List<String> args) async {
   final parser = ArgParser()
+    ..addOption('benchmark', abbr: 'b', help: 'One of: registerSingleton, chainSingleton, chainFactory, chainAsync, named, override, all', defaultsTo: 'chainSingleton')
     ..addOption('chainCount', abbr: 'c', help: 'Comma-separated chainCounts', defaultsTo: '10')
     ..addOption('nestingDepth', abbr: 'd', help: 'Comma-separated depths', defaultsTo: '5')
-    ..addOption('mode', abbr: 'm', help: 'Mode (singletonStrategy,factoryStrategy,asyncStrategy)', defaultsTo: 'singletonStrategy')
     ..addOption('repeat', abbr: 'r', help: 'Repeats for each run (>=2)', defaultsTo: '2')
     ..addOption('warmup', abbr: 'w', help: 'Warmup runs', defaultsTo: '1')
     ..addOption('format', abbr: 'f', help: 'Output format (pretty, csv, json)', defaultsTo: 'pretty')
@@ -20,88 +64,151 @@ Future<void> main(List<String> args) async {
   if (result['help'] == true) {
     print('UniversalChainBenchmark');
     print(parser.usage);
+    print('Example:');
+    print('  dart run bin/main.dart --benchmark=chainFactory --chainCount=10 --nestingDepth=5 --format=csv');
     return;
   }
 
+  final benchName   = result['benchmark'] as String;
+  final isAll = benchName == 'all';
+  final List<UniversalBenchmark> allBenches = [
+    UniversalBenchmark.registerSingleton,
+    UniversalBenchmark.chainSingleton,
+    UniversalBenchmark.chainFactory,
+    UniversalBenchmark.chainAsync,
+    UniversalBenchmark.named,
+    UniversalBenchmark.override,
+  ];
+
+  final List<UniversalBenchmark> benchesToRun = isAll
+    ? allBenches
+    : [
+        UniversalBenchmark.values.firstWhere(
+          (b) => b.toString().split('.').last == benchName,
+          orElse: () => UniversalBenchmark.chainSingleton,
+        ),
+      ];
+
   final chainCounts = _parseIntList(result['chainCount'] as String);
   final nestDepths  = _parseIntList(result['nestingDepth'] as String);
-  final modeName    = result['mode'] as String;
-  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(
+  for (final bench in benchesToRun) {
-    String name,
+    final scenario = _toScenario(bench);
-    int chainCount,
+    final mode     = _toMode(bench);
-    int nestingDepth,
+    for (final c in chainCounts) {
-    List<num> timings,
+      for (final d in nestDepths) {
-    int? memoryDiffKb,
+        // --- asyncChain special case ---
-    int? deltaPeakKb,
+        if (scenario == UniversalScenario.asyncChain) {
-    int? peakRssKb,
+          final di = CherrypickDIAdapter();
-  ) {
+          final benchAsync = UniversalChainAsyncBenchmark(
-    timings.sort();
+            di,
-    var mean = timings.reduce((a, b) => a + b) / timings.length;
+            chainCount: c,
-    var median = timings[timings.length ~/ 2];
+            nestingDepth: d,
-    var minVal = timings.first;
+            mode: mode,
-    var maxVal = timings.last;
+          );
-    var stddev = sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
+          final timings = <num>[];
-    results.add({
+          final rssValues = <int>[];
-      'benchmark': name,
+          // Warmup
-      'chainCount': chainCount,
+          for (int i = 0; i < warmups; i++) {
-      'nestingDepth': nestingDepth,
+            await benchAsync.setup();
-      'mean_us': mean.round(),
+            await benchAsync.run();
-      'median_us': median.round(),
+            await benchAsync.teardown();
-      'stddev_us': stddev.round(),
+          }
-      'min_us': minVal.round(),
+          final memBefore = ProcessInfo.currentRss;
-      'max_us': maxVal.round(),
+          for (int i = 0; i < repeats; i++) {
-      'trials': timings.length,
+            await benchAsync.setup();
-      'timings_us': timings.map((t) => t.round()).toList(),
+            final sw = Stopwatch()..start();
-      'memory_diff_kb': memoryDiffKb,
+            await benchAsync.run();
-      'delta_peak_kb': deltaPeakKb,
+            sw.stop();
-      'peak_rss_kb': peakRssKb,
+            timings.add(sw.elapsedMicroseconds);
-    });
+            rssValues.add(ProcessInfo.currentRss);
-  }
+            await benchAsync.teardown();
-
+          }
-  Future<void> runAndCollect(
+          final memAfter = ProcessInfo.currentRss;
-    String name,
+          final memDiffKB = ((memAfter - memBefore) / 1024).round();
-    Future<num> Function() fn, {
+          final peakRss = [...rssValues, memBefore].reduce(max);
-    required int chainCount,
+          final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
-    required int nestingDepth,
+          timings.sort();
-  }) async {
+          var mean = timings.reduce((a, b) => a + b) / timings.length;
-    for (int i = 0; i < warmups; i++) {
+          var median = timings[timings.length ~/ 2];
-      await fn();
+          var minVal = timings.first;
-    }
+          var maxVal = timings.last;
-    final timings = <num>[];
+          var stddev = sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
-    final rssValues = <int>[];
+          results.add({
-    final memBefore = ProcessInfo.currentRss;
+            'benchmark': 'Universal_$bench',
-    for (int i = 0; i < repeats; i++) {
+            'chainCount': c,
-      timings.add(await fn());
+            'nestingDepth': d,
-      rssValues.add(ProcessInfo.currentRss);
+            'mean_us': mean.round(),
-    }
+            'median_us': median.round(),
-    final memAfter = ProcessInfo.currentRss;
+            'stddev_us': stddev.round(),
-    final memDiffKB = ((memAfter - memBefore) / 1024).round();
+            'min_us': minVal.round(),
-    final peakRss = [...rssValues, memBefore].reduce(max);
+            'max_us': maxVal.round(),
-    final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
+            'trials': timings.length,
-    addResult(name, chainCount, nestingDepth, timings, memDiffKB, deltaPeakKb, (peakRss/1024).round());
+            'timings_us': timings.map((t) => t.round()).toList(),
-  }
+            'memory_diff_kb': memDiffKB,
-
+            'delta_peak_kb': deltaPeakKb,
-  for (final c in chainCounts) {
+            'peak_rss_kb': (peakRss / 1024).round(),
-    for (final d in nestDepths) {
+          });
-      await runAndCollect('UniversalChain_$mode', () async {
+          continue;
-        return _captureReport(() => UniversalChainBenchmark(
+        }
+        // --- Sync-case ---
+        final di = CherrypickDIAdapter();
+        final benchSync = UniversalChainBenchmark(
           di,
           chainCount: c,
           nestingDepth: d,
           mode: mode,
-        ).report());
+          scenario: scenario,
-      }, chainCount: c, nestingDepth: d);
+        );
+        final timings = <num>[];
+        final rssValues = <int>[];
+        // Warmup
+        for (int i = 0; i < warmups; i++) {
+          benchSync.setup();
+          benchSync.run();
+          benchSync.teardown();
+        }
+        final memBefore = ProcessInfo.currentRss;
+        for (int i = 0; i < repeats; i++) {
+          benchSync.setup();
+          final sw = Stopwatch()..start();
+          benchSync.run();
+          sw.stop();
+          timings.add(sw.elapsedMicroseconds);
+          rssValues.add(ProcessInfo.currentRss);
+          benchSync.teardown();
+        }
+        final memAfter = ProcessInfo.currentRss;
+        final memDiffKB = ((memAfter - memBefore) / 1024).round();
+        final peakRss = [...rssValues, memBefore].reduce(max);
+        final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
+        timings.sort();
+        var mean = timings.reduce((a, b) => a + b) / timings.length;
+        var median = timings[timings.length ~/ 2];
+        var minVal = timings.first;
+        var maxVal = timings.last;
+        var stddev = sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
+        results.add({
+          'benchmark': 'Universal_$bench',
+          'chainCount': c,
+          'nestingDepth': d,
+          'mean_us': mean.round(),
+          'median_us': median.round(),
+          'stddev_us': stddev.round(),
+          'min_us': minVal.round(),
+          'max_us': maxVal.round(),
+          'trials': timings.length,
+          'timings_us': timings.map((t) => t.round()).toList(),
+          'memory_diff_kb': memDiffKB,
+          'delta_peak_kb': deltaPeakKb,
+          'peak_rss_kb': (peakRss / 1024).round(),
+        });
+      }
     }
   }
 
@@ -117,13 +224,6 @@ Future<void> main(List<String> args) async {
 // --- helpers ---
 List<int> _parseIntList(String s) => s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();
 
-Future<num> _captureReport(void Function() fn) async {
-  final sw = Stopwatch()..start();
-  fn();
-  sw.stop();
-  return sw.elapsedMicroseconds;
-}
-
 String _toPretty(List<Map<String, dynamic>> rows) {
   final keys = [
     'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
@@ -133,7 +233,6 @@ String _toPretty(List<Map<String, dynamic>> rows) {
   final lines = rows.map((r) => keys.map((k) => (r[k] ?? '').toString()).join('\t')).toList();
   return ([header] + lines).join('\n');
 }
-
 String _toCsv(List<Map<String, dynamic>> rows) {
   final keys = [
     'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
@@ -149,7 +248,6 @@ String _toCsv(List<Map<String, dynamic>> rows) {
   ).toList();
   return ([header] + lines).join('\n');
 }
-
 String _toJson(List<Map<String, dynamic>> rows) {
   return '[\n${rows.map((r) => '  $r').join(',\n')}\n]';
 }

benchmark_cherrypick/lib/benchmarks/universal_chain_async_benchmark.dart

@@ -0,0 +1,41 @@
+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 UniversalChainAsyncBenchmark extends AsyncBenchmarkBase {
+  final DIAdapter di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+
+  UniversalChainAsyncBenchmark(
+    this.di, {
+    this.chainCount = 1,
+    this.nestingDepth = 3,
+    this.mode = UniversalBindingMode.asyncStrategy,
+  }) : super('UniversalAsync: asyncChain/$mode CD=$chainCount/$nestingDepth');
+
+  @override
+  Future<void> setup() async {
+    di.setupModules([
+      UniversalChainModule(
+        chainCount: chainCount,
+        nestingDepth: nestingDepth,
+        bindingMode: mode,
+        scenario: UniversalScenario.asyncChain,
+      )
+    ]);
+  }
+
+  @override
+  Future<void> teardown() async {
+    di.teardown();
+  }
+
+  @override
+  Future<void> run() async {
+    final serviceName = '${chainCount}_$nestingDepth';
+    await di.resolveAsync<UniversalService>(named: serviceName);
+  }
+}

benchmark_cherrypick/lib/benchmarks/universal_chain_benchmark.dart

@@ -4,37 +4,77 @@ 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 DIAdapter _di;
   final int chainCount;
   final int nestingDepth;
   final UniversalBindingMode mode;
+  final UniversalScenario scenario;
+  DIAdapter? _childDi;
 
   UniversalChainBenchmark(
-      this.di, {
+    this._di, {
-      this.chainCount = 1,
+    this.chainCount = 1,
-      this.nestingDepth = 3,
+    this.nestingDepth = 3,
-      this.mode = UniversalBindingMode.singletonStrategy,
+    this.mode = UniversalBindingMode.singletonStrategy,
-    }) : super(
+    this.scenario = UniversalScenario.chain,
-          'UniversalChain: $mode. C/D = $chainCount/$nestingDepth',
+  }) : super('Universal: $scenario/$mode CD=$chainCount/$nestingDepth');
-        );
 
   @override
   void setup() {
-    di.setupModules([
+    switch (scenario) {
-      UniversalChainModule(
+      case UniversalScenario.override:
-        chainCount: chainCount,
+        _di.setupModules([
-        nestingDepth: nestingDepth,
+          UniversalChainModule(
-        bindingMode: mode,
+            chainCount: chainCount,
-      ),
+            nestingDepth: nestingDepth,
-    ]);
+            bindingMode: UniversalBindingMode.singletonStrategy,
+            scenario: UniversalScenario.register,
+          )
+        ]);
+        _childDi = _di.openSubScope('child');
+        _childDi!.setupModules([
+          UniversalChainModule(
+            chainCount: chainCount,
+            nestingDepth: nestingDepth,
+            bindingMode: UniversalBindingMode.singletonStrategy,
+            scenario: UniversalScenario.register,
+          )
+        ]);
+        break;
+      default:
+        _di.setupModules([
+          UniversalChainModule(
+            chainCount: chainCount,
+            nestingDepth: nestingDepth,
+            bindingMode: mode,
+            scenario: scenario,
+          )
+        ]);
+        break;
+    }
   }
 
   @override
-  void teardown() => di.teardown();
+  void teardown() => _di.teardown();
 
   @override
   void run() {
-    final serviceName = '${chainCount}_$nestingDepth';
+    switch (scenario) {
-    di.resolve<UniversalService>(named: serviceName);
+      case UniversalScenario.register:
+        _di.resolve<UniversalService>();
+        break;
+      case UniversalScenario.named:
+        _di.resolve<Object>(named: 'impl2');
+        break;
+      case UniversalScenario.chain:
+        final serviceName = '${chainCount}_$nestingDepth';
+        _di.resolve<UniversalService>(named: serviceName);
+        break;
+      case UniversalScenario.override:
+        _childDi!.resolve<UniversalService>();
+        break;
+      case UniversalScenario.asyncChain:
+        throw UnsupportedError('asyncChain supported only in UniversalChainAsyncBenchmark');
+    }
   }
 }

benchmark_cherrypick/lib/scenarios/universal_chain_module.dart

@@ -7,54 +7,107 @@ enum UniversalBindingMode {
   asyncStrategy,
 }
 
+enum UniversalScenario {
+  register,
+  chain,
+  named,
+  override,
+  asyncChain,
+}
+
 class UniversalChainModule extends Module {
   final int chainCount;
   final int nestingDepth;
   final UniversalBindingMode bindingMode;
+  final UniversalScenario scenario;
 
   UniversalChainModule({
     required this.chainCount,
     required this.nestingDepth,
     this.bindingMode = UniversalBindingMode.singletonStrategy,
+    this.scenario = UniversalScenario.chain,
   });
 
   @override
   void builder(Scope currentScope) {
-    for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
+    if (scenario == UniversalScenario.asyncChain) {
-      for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
+      for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
-        final chain = chainIndex + 1;
+        for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
-        final level = levelIndex + 1;
+          final chain = chainIndex + 1;
-        final prevDepName = '${chain}_${level - 1}';
+          final level = levelIndex + 1;
-        final depName = '${chain}_$level';
+          final prevDepName = '${chain}_${level - 1}';
-        switch (bindingMode) {
+          final depName = '${chain}_$level';
-          case UniversalBindingMode.singletonStrategy:
+          bind<UniversalService>()
-            bind<UniversalService>()
+            .toProvideAsync(() async {
-                .toProvide(() => UniversalServiceImpl(
+              final prev = level > 1
-                  value: depName,
+                  ? await currentScope.resolveAsync<UniversalService>(named: prevDepName)
-                  dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                  : null;
-                ))
+              return UniversalServiceImpl(
-                .withName(depName)
+                value: depName,
-                .singleton();
+                dependency: prev,
-            break;
+              );
-          case UniversalBindingMode.factoryStrategy:
+            })
-            bind<UniversalService>()
+            .withName(depName)
-                .toProvide(() => UniversalServiceImpl(
+            .singleton();
-                  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;
         }
       }
+      return;
+    }
+
+    switch (scenario) {
+      case UniversalScenario.register:
+        bind<UniversalService>()
+            .toProvide(() => UniversalServiceImpl(value: 'reg', dependency: null))
+            .singleton();
+        break;
+      case UniversalScenario.named:
+        bind<Object>().toProvide(() => UniversalServiceImpl(value: 'impl1')).withName('impl1');
+        bind<Object>().toProvide(() => UniversalServiceImpl(value: 'impl2')).withName('impl2');
+        break;
+      case UniversalScenario.chain:
+        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;
+            }
+          }
+        }
+        break;
+      case UniversalScenario.override:
+        // handled at benchmark level
+        break;
+      case UniversalScenario.asyncChain:
+        // already handled above
+        break;
     }
   }
 }