refactor: rename benchmark_cherrypick to benchmark_di, update paths, pubspec, imports, and documentation

benchmark_di/lib/benchmarks/universal_chain_async_benchmark.dart

@@ -0,0 +1,42 @@
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_di/di_adapters/di_adapter.dart';
+import 'package:benchmark_di/scenarios/universal_chain_module.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+import 'package:benchmark_di/scenarios/di_universal_registration.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.setupDependencies(getUniversalRegistration(
+      di,
+      chainCount: chainCount,
+      nestingDepth: nestingDepth,
+      bindingMode: mode,
+      scenario: UniversalScenario.asyncChain,
+    ));
+    await di.waitForAsyncReady();
+  }
+
+  @override
+  Future<void> teardown() async {
+    di.teardown();
+  }
+
+  @override
+  Future<void> run() async {
+    final serviceName = '${chainCount}_$nestingDepth';
+    await di.resolveAsync<UniversalService>(named: serviceName);
+  }
+}

benchmark_di/lib/benchmarks/universal_chain_benchmark.dart

@@ -0,0 +1,82 @@
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_di/di_adapters/di_adapter.dart';
+import 'package:benchmark_di/scenarios/universal_chain_module.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+import 'package:benchmark_di/scenarios/di_universal_registration.dart';
+
+class UniversalChainBenchmark extends BenchmarkBase {
+  final DIAdapter _di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+  final UniversalScenario scenario;
+  DIAdapter? _childDi;
+
+  UniversalChainBenchmark(
+    this._di, {
+    this.chainCount = 1,
+    this.nestingDepth = 3,
+    this.mode = UniversalBindingMode.singletonStrategy,
+    this.scenario = UniversalScenario.chain,
+  }) : super('Universal: $scenario/$mode CD=$chainCount/$nestingDepth');
+
+  @override
+  void setup() {
+    switch (scenario) {
+      case UniversalScenario.override:
+        _di.setupDependencies(getUniversalRegistration(
+          _di,
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: UniversalBindingMode.singletonStrategy,
+          scenario: UniversalScenario.chain,
+        ));
+        _childDi = _di.openSubScope('child');
+        _childDi!.setupDependencies(getUniversalRegistration(
+          _childDi!,
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: UniversalBindingMode.singletonStrategy,
+          scenario: UniversalScenario.chain, // критично: цепочку, а не просто alias!
+        ));
+        break;
+      default:
+        _di.setupDependencies(getUniversalRegistration(
+          _di,
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: mode,
+          scenario: scenario,
+        ));
+        break;
+    }
+  }
+
+  @override
+  void teardown() => _di.teardown();
+
+  @override
+  void run() {
+    switch (scenario) {
+      case UniversalScenario.register:
+        _di.resolve<UniversalService>();
+        break;
+      case UniversalScenario.named:
+        if (_di.runtimeType.toString().contains('GetItAdapter')) {
+          _di.resolve<UniversalService>(named: 'impl2');
+        } else {
+          _di.resolve<UniversalService>(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_di/lib/cli/benchmark_cli.dart

@@ -0,0 +1,85 @@
+import 'dart:math';
+
+import 'package:benchmark_di/cli/report/markdown_report.dart';
+
+import '../scenarios/universal_chain_module.dart';
+import 'report/pretty_report.dart';
+import 'report/csv_report.dart';
+import 'report/json_report.dart';
+import 'parser.dart';
+import 'runner.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
+import 'package:benchmark_di/di_adapters/cherrypick_adapter.dart';
+import 'package:benchmark_di/di_adapters/get_it_adapter.dart';
+
+/// Command-line interface (CLI) runner for benchmarks.
+///
+/// Parses CLI arguments, orchestrates benchmarks for different
+/// scenarios and configurations, collects results, and generates reports
+/// in the desired output format.
+class BenchmarkCliRunner {
+  /// Runs benchmarks based on CLI [args], configuring different test scenarios.
+  Future<void> run(List<String> args) async {
+    final config = parseBenchmarkCli(args);
+    final results = <Map<String, dynamic>>[];
+    for (final bench in config.benchesToRun) {
+      final scenario = toScenario(bench);
+      final mode = toMode(bench);
+      for (final c in config.chainCounts) {
+        for (final d in config.nestDepths) {
+          BenchmarkResult benchResult;
+          final di = config.di == 'getit' ? GetItAdapter() : CherrypickDIAdapter();
+          if (scenario == UniversalScenario.asyncChain) {
+            final benchAsync = UniversalChainAsyncBenchmark(di,
+              chainCount: c, nestingDepth: d, mode: mode,
+            );
+            benchResult = await BenchmarkRunner.runAsync(
+              benchmark: benchAsync,
+              warmups: config.warmups,
+              repeats: config.repeats,
+            );
+          } else {
+            final benchSync = UniversalChainBenchmark(di,
+              chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+            );
+            benchResult = await BenchmarkRunner.runSync(
+              benchmark: benchSync,
+              warmups: config.warmups,
+              repeats: config.repeats,
+            );
+          }
+          final timings = benchResult.timings;
+          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 = timings.isEmpty ? 0 : 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.toStringAsFixed(2),
+            'median_us': median.toStringAsFixed(2),
+            'stddev_us': stddev.toStringAsFixed(2),
+            'min_us': minVal.toStringAsFixed(2),
+            'max_us': maxVal.toStringAsFixed(2),
+            'trials': timings.length,
+            'timings_us': timings.map((t) => t.toStringAsFixed(2)).toList(),
+            'memory_diff_kb': benchResult.memoryDiffKb,
+            'delta_peak_kb': benchResult.deltaPeakKb,
+            'peak_rss_kb': benchResult.peakRssKb,
+          });
+        }
+      }
+    }
+    final reportGenerators = {
+      'pretty': PrettyReport(),
+      'csv': CsvReport(),
+      'json': JsonReport(),
+      'markdown': MarkdownReport(),
+    };
+    print(reportGenerators[config.format]?.render(results) ?? PrettyReport().render(results));
+  }
+}

benchmark_di/lib/cli/parser.dart

@@ -0,0 +1,129 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:benchmark_di/scenarios/universal_chain_module.dart';
+
+/// Enum describing all supported Universal DI benchmark types.
+enum UniversalBenchmark {
+  /// Simple singleton registration benchmark
+  registerSingleton,
+  /// Chain of singleton dependencies
+  chainSingleton,
+  /// Chain using factories
+  chainFactory,
+  /// Async chain resolution
+  chainAsync,
+  /// Named registration benchmark
+  named,
+  /// Override/child-scope benchmark
+  override,
+}
+
+/// Maps [UniversalBenchmark] to the scenario enum for DI chains.
+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;
+  }
+}
+
+/// Maps benchmark to registration mode (singleton/factory/async).
+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;
+  }
+}
+
+/// Utility to parse a string into its corresponding enum value [T].
+T parseEnum<T>(String value, List<T> values, T defaultValue) {
+  return values.firstWhere(
+    (v) => v.toString().split('.').last.toLowerCase() == value.toLowerCase(),
+    orElse: () => defaultValue,
+  );
+}
+
+/// Parses comma-separated integer list from [s].
+List<int> parseIntList(String s) =>
+    s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();
+
+/// CLI config describing what and how to benchmark.
+class BenchmarkCliConfig {
+  /// Benchmarks enabled to run (scenarios).
+  final List<UniversalBenchmark> benchesToRun;
+  /// List of chain counts (parallel, per test).
+  final List<int> chainCounts;
+  /// List of nesting depths (max chain length, per test).
+  final List<int> nestDepths;
+  /// How many times to repeat each trial.
+  final int repeats;
+  /// How many times to warm-up before measuring.
+  final int warmups;
+  /// Output report format.
+  final String format;
+  /// Name of DI implementation ("cherrypick" or "getit")
+  final String di;
+  BenchmarkCliConfig({
+    required this.benchesToRun,
+    required this.chainCounts,
+    required this.nestDepths,
+    required this.repeats,
+    required this.warmups,
+    required this.format,
+    required this.di,
+  });
+}
+
+/// Parses CLI arguments [args] into a [BenchmarkCliConfig].
+/// Supports --benchmark, --chainCount, --nestingDepth, etc.
+BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
+  final parser = ArgParser()
+    ..addOption('benchmark', abbr: 'b', defaultsTo: 'chainSingleton')
+    ..addOption('chainCount', abbr: 'c', defaultsTo: '10')
+    ..addOption('nestingDepth', abbr: 'd', defaultsTo: '5')
+    ..addOption('repeat', abbr: 'r', defaultsTo: '2')
+    ..addOption('warmup', abbr: 'w', defaultsTo: '1')
+    ..addOption('format', abbr: 'f', defaultsTo: 'pretty')
+    ..addOption('di', defaultsTo: 'cherrypick', help: 'DI implementation: cherrypick or getit')
+    ..addFlag('help', abbr: 'h', negatable: false, help: 'Show help');
+  final result = parser.parse(args);
+  if (result['help'] == true) {
+    print(parser.usage);
+    exit(0);
+  }
+  final benchName = result['benchmark'] as String;
+  final isAll = benchName == 'all';
+  final allBenches = UniversalBenchmark.values;
+  final benchesToRun = isAll
+      ? allBenches
+      : [parseEnum(benchName, allBenches, UniversalBenchmark.chainSingleton)];
+  return BenchmarkCliConfig(
+    benchesToRun: benchesToRun,
+    chainCounts: parseIntList(result['chainCount'] as String),
+    nestDepths: parseIntList(result['nestingDepth'] as String),
+    repeats: int.tryParse(result['repeat'] as String? ?? "") ?? 2,
+    warmups: int.tryParse(result['warmup'] as String? ?? "") ?? 1,
+    format: result['format'] as String,
+    di: result['di'] as String? ?? 'cherrypick',
+  );
+}

benchmark_di/lib/cli/report/csv_report.dart

@@ -0,0 +1,24 @@
+import 'report_generator.dart';
+
+/// Generates a CSV-formatted report for benchmark results.
+class CsvReport extends ReportGenerator {
+  /// List of all keys/columns to include in the CSV output.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','timings_us','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+  /// Renders rows as a CSV table string.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final header = keys.join(',');
+    final lines = rows.map((r) =>
+      keys.map((k) {
+        final v = r[k];
+        if (v is List) return '"${v.join(';')}"';
+        return (v ?? '').toString();
+      }).join(',')
+    ).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_di/lib/cli/report/json_report.dart

@@ -0,0 +1,13 @@
+import 'report_generator.dart';
+
+/// Generates a JSON-formatted report for benchmark results.
+class JsonReport extends ReportGenerator {
+  /// No specific keys; outputs all fields in raw map.
+  @override
+  List<String> get keys => [];
+  /// Renders all result rows as a pretty-printed JSON array.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    return '[\n${rows.map((r) => '  $r').join(',\n')}\n]';
+  }
+}

benchmark_di/lib/cli/report/markdown_report.dart

@@ -0,0 +1,78 @@
+import 'report_generator.dart';
+
+/// Generates a Markdown-formatted report for benchmark results.
+///
+/// Displays result rows as a visually clear Markdown table including a legend for all metrics.
+class MarkdownReport extends ReportGenerator {
+  /// List of columns (keys) to show in the Markdown table.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+
+  /// Friendly display names for each benchmark type.
+  static const nameMap = {
+    'Universal_UniversalBenchmark.registerSingleton':'RegisterSingleton',
+    'Universal_UniversalBenchmark.chainSingleton':'ChainSingleton',
+    'Universal_UniversalBenchmark.chainFactory':'ChainFactory',
+    'Universal_UniversalBenchmark.chainAsync':'AsyncChain',
+    'Universal_UniversalBenchmark.named':'Named',
+    'Universal_UniversalBenchmark.override':'Override',
+  };
+
+  /// Renders all results as a formatted Markdown table with aligned columns and a legend.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final headers = [
+      'Benchmark', 'Chain Count', 'Depth', 'Mean (us)', 'Median', 'Stddev', 'Min', 'Max', 'N', 'ΔRSS(KB)', 'ΔPeak(KB)', 'PeakRSS(KB)'
+    ];
+    final dataRows = rows.map((r) {
+      final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
+      return [
+        readableName,
+        r['chainCount'],
+        r['nestingDepth'],
+        r['mean_us'],
+        r['median_us'],
+        r['stddev_us'],
+        r['min_us'],
+        r['max_us'],
+        r['trials'],
+        r['memory_diff_kb'],
+        r['delta_peak_kb'],
+        r['peak_rss_kb'],
+      ].map((cell) => cell.toString()).toList();
+    }).toList();
+
+    // Calculate column width for pretty alignment
+    final all = [headers] + dataRows;
+    final widths = List.generate(headers.length, (i) {
+      return all.map((row) => row[i].length).reduce((a, b) => a > b ? a : b);
+    });
+
+    String rowToLine(List<String> row, {String sep = ' | '}) =>
+        '| ${List.generate(row.length, (i) => row[i].padRight(widths[i])).join(sep)} |';
+
+    final headerLine = rowToLine(headers);
+    final divider = '| ${widths.map((w) => '-' * w).join(' | ')} |';
+    final lines = dataRows.map(rowToLine).toList();
+
+    final legend = '''
+      > **Legend:**  
+      > `Benchmark` – Test name  
+      > `Chain Count` – Number of independent chains  
+      > `Depth` – Depth of each chain  
+      > `Mean (us)` – Average time per run (microseconds)  
+      > `Median` – Median time per run  
+      > `Stddev` – Standard deviation  
+      > `Min`, `Max` – Min/max run time  
+      > `N` – Number of measurements  
+      > `ΔRSS(KB)` – Change in process memory (KB)  
+      > `ΔPeak(KB)` – Change in peak RSS (KB)  
+      > `PeakRSS(KB)` – Max observed RSS memory (KB)  
+      ''';
+
+    return '$legend\n\n${([headerLine, divider] + lines).join('\n')}' ;
+  }
+}

benchmark_di/lib/cli/report/pretty_report.dart

@@ -0,0 +1,50 @@
+import 'report_generator.dart';
+
+/// Generates a human-readable, tab-delimited report for benchmark results.
+///
+/// Used for terminal and log output; shows each result as a single line with labeled headers.
+class PrettyReport extends ReportGenerator {
+  /// List of columns to output in the pretty report.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+
+  /// Mappings from internal benchmark IDs to display names.
+  static const nameMap = {
+    'Universal_UniversalBenchmark.registerSingleton':    'RegisterSingleton',
+    'Universal_UniversalBenchmark.chainSingleton':       'ChainSingleton',
+    'Universal_UniversalBenchmark.chainFactory':         'ChainFactory',
+    'Universal_UniversalBenchmark.chainAsync':           'AsyncChain',
+    'Universal_UniversalBenchmark.named':                'Named',
+    'Universal_UniversalBenchmark.override':             'Override',
+  };
+
+  /// Renders the results as a header + tab-separated value table.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final headers = [
+      'Benchmark', 'Chain Count', 'Depth', 'Mean (us)', 'Median', 'Stddev', 'Min', 'Max', 'N', 'ΔRSS(KB)', 'ΔPeak(KB)', 'PeakRSS(KB)'
+    ];
+    final header = headers.join('\t');
+    final lines = rows.map((r) {
+      final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
+      return [
+        readableName,
+        r['chainCount'],
+        r['nestingDepth'],
+        r['mean_us'],
+        r['median_us'],
+        r['stddev_us'],
+        r['min_us'],
+        r['max_us'],
+        r['trials'],
+        r['memory_diff_kb'],
+        r['delta_peak_kb'],
+        r['peak_rss_kb'],
+      ].join('\t');
+    }).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_di/lib/cli/report/report_generator.dart

@@ -0,0 +1,9 @@
+/// Abstract base for generating benchmark result reports in different formats.
+///
+/// Subclasses implement [render] to output results, and [keys] to define columns (if any).
+abstract class ReportGenerator {
+  /// Renders the given [results] as a formatted string (table, markdown, csv, etc).
+  String render(List<Map<String, dynamic>> results);
+  /// List of output columns/keys included in the export (or [] for auto/all).
+  List<String> get keys;
+}

benchmark_di/lib/cli/runner.dart

@@ -0,0 +1,96 @@
+import 'dart:io';
+import 'dart:math';
+import 'package:benchmark_di/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
+
+/// Holds the results for a single benchmark execution.
+class BenchmarkResult {
+  /// List of timings for each run (in microseconds).
+  final List<num> timings;
+  /// Difference in memory (RSS, in KB) after running.
+  final int memoryDiffKb;
+  /// Difference between peak RSS and initial RSS (in KB).
+  final int deltaPeakKb;
+  /// Peak RSS memory observed (in KB).
+  final int peakRssKb;
+  BenchmarkResult({
+    required this.timings,
+    required this.memoryDiffKb,
+    required this.deltaPeakKb,
+    required this.peakRssKb,
+  });
+  /// Computes a BenchmarkResult instance from run timings and memory data.
+  factory BenchmarkResult.collect({
+    required List<num> timings,
+    required List<int> rssValues,
+    required int memBefore,
+  }) {
+    final memAfter = ProcessInfo.currentRss;
+    final memDiffKB = ((memAfter - memBefore) / 1024).round();
+    final peakRss = [...rssValues, memBefore].reduce(max);
+    final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
+    return BenchmarkResult(
+      timings: timings,
+      memoryDiffKb: memDiffKB,
+      deltaPeakKb: deltaPeakKb,
+      peakRssKb: (peakRss / 1024).round(),
+    );
+  }
+}
+
+/// Static methods to execute and time benchmarks for DI containers.
+class BenchmarkRunner {
+  /// Runs a synchronous benchmark ([UniversalChainBenchmark]) for a given number of [warmups] and [repeats].
+  /// Collects execution time and observed memory.
+  static Future<BenchmarkResult> runSync({
+    required UniversalChainBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      benchmark.setup();
+      benchmark.run();
+      benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      benchmark.setup();
+      final sw = Stopwatch()..start();
+      benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+
+  /// Runs an asynchronous benchmark ([UniversalChainAsyncBenchmark]) for a given number of [warmups] and [repeats].
+  /// Collects execution time and observed memory.
+  static Future<BenchmarkResult> runAsync({
+    required UniversalChainAsyncBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      await benchmark.setup();
+      await benchmark.run();
+      await benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      await benchmark.setup();
+      final sw = Stopwatch()..start();
+      await benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      await benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+}

benchmark_di/lib/di_adapters/cherrypick_adapter.dart

@@ -0,0 +1,65 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'di_adapter.dart';
+
+/// DIAdapter implementation for the CherryPick DI library using registration callbacks.
+class CherrypickDIAdapter implements DIAdapter {
+  Scope? _scope;
+  
+  @override
+  void setupDependencies(void Function(dynamic container) registration) {
+    _scope = CherryPick.openRootScope();
+    registration(_scope!);
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) =>
+      named == null ? _scope!.resolve<T>() : _scope!.resolve<T>(named: named);
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async =>
+      named == null ? await _scope!.resolveAsync<T>() : await _scope!.resolveAsync<T>(named: named);
+
+  @override
+  void teardown() {
+    CherryPick.closeRootScope();
+    _scope = null;
+  }
+
+  @override
+  CherrypickDIAdapter openSubScope(String name) {
+    final sub = _scope!.openSubScope(name);
+    return _CherrypickSubScopeAdapter(sub);
+  }
+
+  @override
+  Future<void> waitForAsyncReady() async {}
+}
+
+/// Internal adapter for a CherryPick sub-scope (callbacks based).
+class _CherrypickSubScopeAdapter extends CherrypickDIAdapter {
+  final Scope _subScope;
+  _CherrypickSubScopeAdapter(this._subScope);
+
+  @override
+  void setupDependencies(void Function(dynamic container) registration) {
+    registration(_subScope);
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) =>
+      named == null ? _subScope.resolve<T>() : _subScope.resolve<T>(named: named);
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async =>
+      named == null ? await _subScope.resolveAsync<T>() : await _subScope.resolveAsync<T>(named: named);
+
+  @override
+  void teardown() {
+    // subScope teardown не требуется
+  }
+
+  @override
+  CherrypickDIAdapter openSubScope(String name) {
+    return _CherrypickSubScopeAdapter(_subScope.openSubScope(name));
+  }
+}

benchmark_di/lib/di_adapters/di_adapter.dart

@@ -0,0 +1,24 @@
+/// Абстракция для DI-адаптера с использованием функций регистрации.
+///
+/// Позволяет использовать любые DI-контейнеры: и модульные, и безмодульные.
+abstract class DIAdapter {
+  /// Устанавливает зависимости с помощью одной функции регистрации.
+  ///
+  /// Функция принимает выбранный DI-контейнер, задаваемый реализацией.
+  void setupDependencies(void Function(dynamic container) registration);
+
+  /// Резолвит (возвращает) экземпляр типа [T] (по имени, если требуется).
+  T resolve<T extends Object>({String? named});
+
+  /// Асинхронно резолвит экземпляр типа [T].
+  Future<T> resolveAsync<T extends Object>({String? named});
+
+  /// Уничтожает/отчищает DI-контейнер.
+  void teardown();
+
+  /// Открывает дочерний под-scope (если применимо).
+  DIAdapter openSubScope(String name);
+
+  /// Ожидание готовности DI контейнера (нужно для async DI, например get_it)
+  Future<void> waitForAsyncReady();
+}

benchmark_di/lib/di_adapters/get_it_adapter.dart

@@ -0,0 +1,32 @@
+import 'package:get_it/get_it.dart';
+import 'di_adapter.dart';
+
+class GetItAdapter implements DIAdapter {
+  late GetIt _getIt;
+
+  @override
+  void setupDependencies(void Function(dynamic container) registration) {
+    _getIt = GetIt.asNewInstance();
+    registration(_getIt);
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) => _getIt<T>(instanceName: named);
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async => _getIt<T>(instanceName: named);
+
+  @override
+  void teardown() => _getIt.reset();
+
+  @override
+  DIAdapter openSubScope(String name) {
+    // get_it не поддерживает scope, возвращаем новый инстанс
+    return GetItAdapter();
+  }
+
+  @override
+  Future<void> waitForAsyncReady() async {
+    await _getIt.allReady();
+  }
+}

benchmark_di/lib/scenarios/di_universal_registration.dart

@@ -0,0 +1,109 @@
+import 'package:benchmark_di/scenarios/universal_service.dart';
+
+import '../di_adapters/di_adapter.dart';
+import '../di_adapters/cherrypick_adapter.dart';
+import '../di_adapters/get_it_adapter.dart';
+import 'universal_chain_module.dart';
+import 'universal_service.dart';
+import 'package:get_it/get_it.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+/// Возвращает универсальную функцию регистрации зависимостей,
+/// подходящую под выбранный DI-адаптер.
+void Function(dynamic) getUniversalRegistration(
+  DIAdapter adapter, {
+  required int chainCount,
+  required int nestingDepth,
+  required UniversalBindingMode bindingMode,
+  required UniversalScenario scenario,
+}) {
+  if (adapter is CherrypickDIAdapter) {
+    return (scope) {
+      scope.installModules([
+        UniversalChainModule(
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: bindingMode,
+          scenario: scenario,
+        ),
+      ]);
+    };
+  } else if (adapter is GetItAdapter) {
+    return (getIt) {
+      switch (scenario) {
+        case UniversalScenario.asyncChain:
+          for (int chain = 1; chain <= chainCount; chain++) {
+            for (int level = 1; level <= nestingDepth; level++) {
+              final prevDepName = '${chain}_${level - 1}';
+              final depName = '${chain}_$level';
+              getIt.registerSingletonAsync<UniversalService>(
+                () async {
+                  final prev = level > 1
+                      ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                      : null;
+                  return UniversalServiceImpl(value: depName, dependency: prev);
+                },
+                instanceName: depName,
+              );
+            }
+          }
+          break;
+        case UniversalScenario.register:
+          getIt.registerSingleton<UniversalService>(UniversalServiceImpl(value: 'reg', dependency: null));
+          break;
+        case UniversalScenario.named:
+          getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl1'), instanceName: 'impl1');
+          getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl2'), instanceName: 'impl2');
+          break;
+        case UniversalScenario.chain:
+          for (int chain = 1; chain <= chainCount; chain++) {
+            for (int level = 1; level <= nestingDepth; level++) {
+              final prevDepName = '${chain}_${level - 1}';
+              final depName = '${chain}_$level';
+              switch (bindingMode) {
+                case UniversalBindingMode.singletonStrategy:
+                  getIt.registerSingleton<UniversalService>(
+                    UniversalServiceImpl(
+                      value: depName,
+                      dependency: level > 1
+                        ? getIt<UniversalService>(instanceName: prevDepName)
+                        : null,
+                    ),
+                    instanceName: depName,
+                  );
+                  break;
+                case UniversalBindingMode.factoryStrategy:
+                  getIt.registerFactory<UniversalService>(
+                    () => UniversalServiceImpl(
+                      value: depName,
+                      dependency: level > 1
+                        ? getIt<UniversalService>(instanceName: prevDepName)
+                        : null,
+                    ),
+                    instanceName: depName,
+                  );
+                  break;
+                case UniversalBindingMode.asyncStrategy:
+                  // getIt не поддерживает асинх. factory напрямую, но можно так:
+                  getIt.registerSingletonAsync<UniversalService>(
+                    () async => UniversalServiceImpl(
+                      value: depName,
+                      dependency: level > 1
+                        ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                        : null,
+                    ),
+                    instanceName: depName,
+                  );
+                  break;
+              }
+            }
+          }
+          break;
+        case UniversalScenario.override:
+          // handled at benchmark level
+          break;
+      }
+    };
+  }
+  throw UnsupportedError('Unknown DIAdapter type: ${adapter.runtimeType}');
+}

benchmark_di/lib/scenarios/universal_chain_module.dart

@@ -0,0 +1,147 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'universal_service.dart';
+
+/// Enum to represent the DI registration/binding mode.
+enum UniversalBindingMode {
+  /// Singleton/provider binding.
+  singletonStrategy,
+
+  /// Factory-based binding.
+  factoryStrategy,
+
+  /// Async-based binding.
+  asyncStrategy,
+}
+
+/// Enum to represent which scenario is constructed for the benchmark.
+enum UniversalScenario {
+  /// Single registration.
+  register,
+  /// Chain of dependencies.
+  chain,
+  /// Named registrations.
+  named,
+  /// Child-scope override scenario.
+  override,
+  /// Asynchronous chain scenario.
+  asyncChain,
+}
+
+/// Test module that generates a chain of service bindings for benchmarking.
+///
+/// Configurable by chain count, nesting depth, binding mode, and scenario
+/// to support various DI performance tests (singleton, factory, async, etc).
+class UniversalChainModule extends Module {
+  /// Number of chains to create.
+  final int chainCount;
+  /// Depth of each chain.
+  final int nestingDepth;
+  /// How modules are registered (factory/singleton/async).
+  final UniversalBindingMode bindingMode;
+  /// Which di scenario to generate (chained, named, etc).
+  final UniversalScenario scenario;
+
+  /// Constructs a configured test DI module for the benchmarks.
+  UniversalChainModule({
+    required this.chainCount,
+    required this.nestingDepth,
+    this.bindingMode = UniversalBindingMode.singletonStrategy,
+    this.scenario = UniversalScenario.chain,
+  });
+
+  @override
+  void builder(Scope currentScope) {
+    if (scenario == UniversalScenario.asyncChain) {
+      // Generate async chain with singleton async bindings.
+      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';
+          bind<UniversalService>()
+            .toProvideAsync(() async {
+              final prev = level > 1
+                  ? await currentScope.resolveAsync<UniversalService>(named: prevDepName)
+                  : null;
+              return UniversalServiceImpl(
+                value: depName,
+                dependency: prev,
+              );
+            })
+            .withName(depName)
+            .singleton();
+        }
+      }
+      return;
+    }
+
+    switch (scenario) {
+      case UniversalScenario.register:
+        // Simple singleton registration.
+        bind<UniversalService>()
+            .toProvide(() => UniversalServiceImpl(value: 'reg', dependency: null))
+            .singleton();
+        break;
+      case UniversalScenario.named:
+        // Named factory registration for two distinct objects.
+        bind<UniversalService>().toProvide(() => UniversalServiceImpl(value: 'impl1')).withName('impl1');
+        bind<UniversalService>().toProvide(() => UniversalServiceImpl(value: 'impl2')).withName('impl2');
+        break;
+      case UniversalScenario.chain:
+        // Chain of nested services, with dependency on previous level by name.
+        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;
+            }
+          }
+        }
+        // Регистрация алиаса без имени (на последний элемент цепочки)
+        final depName = '${chainCount}_${nestingDepth}';
+        bind<UniversalService>()
+            .toProvide(() => currentScope.resolve<UniversalService>(named: depName))
+            .singleton();
+        break;
+      case UniversalScenario.override:
+        // handled at benchmark level, но алиас нужен прямо в этом scope!
+        final depName = '${chainCount}_${nestingDepth}';
+        bind<UniversalService>()
+            .toProvide(() => currentScope.resolve<UniversalService>(named: depName))
+            .singleton();
+        break;
+      case UniversalScenario.asyncChain:
+        // already handled above
+        break;
+    }
+  }
+}

benchmark_di/lib/scenarios/universal_service.dart

@@ -0,0 +1,17 @@
+
+/// Base interface for any universal service in the benchmarks.
+///
+/// Represents an object in the dependency chain with an identifiable value
+/// and (optionally) a dependency on a previous service in the chain.
+abstract class UniversalService {
+  /// String ID for this service instance (e.g. chain/level info).
+  final String value;
+  /// Optional reference to dependency service in the chain.
+  final UniversalService? dependency;
+  UniversalService({required this.value, this.dependency});
+}
+
+/// Default implementation for [UniversalService] used in service chains.
+class UniversalServiceImpl extends UniversalService {
+  UniversalServiceImpl({required super.value, super.dependency});
+}