penkovsky_sa/cherrypick
1
0
Fork 0
mirror of https://github.com/pese-git/cherrypick.git synced 2026-01-23 21:13:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Sergey Penkovsky
2025-08-07 10:34:50 +03:00
parent da79f1e546
commit 6b6564f8c3
24 changed files with 25 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
benchmark_di/README.md Normal file
View File

@@ -0,0 +1,189 @@
# benchmark_di
_Benchmark suite for cherrypick DI container, get_it, and other DI solutions._
## Overview
benchmark_di is a flexible benchmarking suite to compare DI containers (like cherrypick and get_it) on synthetic, deep, and real-world dependency scenarios – chains, factories, async, named, override, etc.
**Features:**
- Universal registration layer and modular scenario setup (works with any DI)
- Built-in support for [cherrypick](https://github.com/) and [get_it](https://pub.dev/packages/get_it)
- Clean CLI for matrix runs and output formats (Markdown, CSV, JSON, pretty)
- Reports metrics: timings, memory (RSS, peak), statistical spreads, and more
- Extendable via your own DIAdapter or benchmark scenarios
---
## Benchmark Scenarios
- **registerSingleton**: Simple singleton registration/resolution
- **chainSingleton**: Resolution of long singleton chains (A→B→C...)
- **chainFactory**: Chain resolution via factories (new instances each time)
- **asyncChain**: Async chain (with async providers)
- **named**: Named/qualified resolution (e.g. from multiple implementations)
- **override**: Resolution and override in subScopes/child adapters
---
## Supported DI
- **cherrypick** (default)
- **get_it**
- Easy to add your own DI by creating a DIAdapter
Switch DI with the CLI option: `--di`
---
## How to Run
1. **Install dependencies:**
```shell
dart pub get
```
2. **Run all benchmarks (default: all scenarios, 2 warmup, 2 repeats):**
```shell
dart run bin/main.dart --benchmark=all --format=markdown
```
3. **For get_it:**
```shell
dart run bin/main.dart --di=getit --benchmark=all --format=markdown
```
4. **Show all CLI options:**
```shell
dart run bin/main.dart --help
```
### CLI Parameters
- `--di` — DI implementation: `cherrypick` (default) or `getit`
- `--benchmark, -b` — Scenario: `registerSingleton`, `chainSingleton`, `chainFactory`, `asyncChain`, `named`, `override`, `all`
- `--chainCount, -c` — Number of parallel chains (e.g. `10,100`)
- `--nestingDepth, -d` — Chain depth (e.g. `5,10`)
- `--repeat, -r` — Measurement repeats (default: 2)
- `--warmup, -w` — Warmup runs (default: 1)
- `--format, -f` — Output: `pretty`, `csv`, `json`, `markdown`
- `--help, -h` — Usage
### Run Examples
- **All benchmarks for cherrypick:**
```shell
dart run bin/main.dart --di=cherrypick --benchmark=all --format=markdown
```
- **For get_it (all scenarios):**
```shell
dart run bin/main.dart --di=getit --benchmark=all --format=markdown
```
- **Specify chains/depth matrix:**
```shell
dart run bin/main.dart --benchmark=chainSingleton --chainCount=10,100 --nestingDepth=5,10 --repeat=3 --format=csv
```
---
## How to Add Your Own DI
1. Implement a class extending `DIAdapter` (`lib/di_adapters/your_adapter.dart`)
2. Register it in CLI (see `cli/benchmark_cli.dart`)
3. Add registration logic to `di_universal_registration.dart` to build chains for your DI
---
## Architecture
```mermaid
classDiagram
class BenchmarkCliRunner {
+run(args)
}
class UniversalChainBenchmark {
+setup()
+run()
+teardown()
}
class UniversalChainAsyncBenchmark {
+setup()
+run()
+teardown()
}
class DIAdapter {
<<interface>>
+setupDependencies(cb)
+resolve<T>(named)
+resolveAsync<T>(named)
+teardown()
+openSubScope(name)
+waitForAsyncReady()
}
class CherrypickDIAdapter
class GetItAdapter
class UniversalChainModule {
+builder(scope)
+chainCount
+nestingDepth
+bindingMode
+scenario
}
class UniversalService {
<<interface>>
+value
+dependency
}
class UniversalServiceImpl {
+UniversalServiceImpl(value, dependency)
}
class di_universal_registration {
+getUniversalRegistration(adapter, ...)
}
class Scope
class UniversalScenario
class UniversalBindingMode
%% Relationships
BenchmarkCliRunner --> UniversalChainBenchmark
BenchmarkCliRunner --> UniversalChainAsyncBenchmark
UniversalChainBenchmark *-- DIAdapter
UniversalChainAsyncBenchmark *-- DIAdapter
DIAdapter <|.. CherrypickDIAdapter
DIAdapter <|.. GetItAdapter
CherrypickDIAdapter ..> Scope
GetItAdapter ..> GetIt: "uses GetIt"
DIAdapter o--> UniversalChainModule : setupDependencies
UniversalChainModule ..> UniversalScenario
UniversalChainModule ..> UniversalBindingMode
UniversalChainModule o-- UniversalServiceImpl : creates
UniversalService <|.. UniversalServiceImpl
UniversalServiceImpl --> UniversalService : dependency
BenchmarkCliRunner ..> di_universal_registration : uses
di_universal_registration ..> DIAdapter
UniversalChainBenchmark ..> di_universal_registration : uses registrar
UniversalChainAsyncBenchmark ..> di_universal_registration : uses registrar
```
---
## Metrics
Always collected:
- **Timings** (microseconds): mean, median, stddev, min, max
- **Memory**: RSS difference, peak RSS
## License
MIT

189
benchmark_di/README.ru.md Normal file
View File

@@ -0,0 +1,189 @@
# benchmark_di
_Бенчмаркинговый набор для cherrypick, get_it и других DI-контейнеров._
## Общее описание
benchmark_di — это современный фреймворк для измерения производительности DI-контейнеров (как cherrypick, так и get_it) на синтетических, сложных и реальных сценариях: цепочки зависимостей, factory, async, именованные биндинги, override и пр.
**Возможности:**
- Универсальный слой регистрации сценариев (работает с любым DI)
- Готовая поддержка [cherrypick](https://github.com/) и [get_it](https://pub.dev/packages/get_it)
- Удобный CLI для запусков по матрице значений параметров и различных форматов вывода (Markdown, CSV, JSON, pretty)
- Сбор и вывод метрик: время, память (RSS, peak), статистика (среднее, медиана, stddev, min/max)
- Легко расширять — создавайте свой DIAdapter и новые сценарии
---
## Сценарии бенчмарков
- **registerSingleton**: Регистрация и резолвинг singleton
- **chainSingleton**: Разрешение длинных singleton-цепочек (A→B→C…)
- **chainFactory**: То же, но с factory (каждый раз — новый объект)
- **asyncChain**: Асинхронная цепочка (async factory/provider)
- **named**: Разрешение по имени (например, из нескольких реализаций)
- **override**: Переопределение зависимостей в subScope
---
## Поддерживаемые DI-контейнеры
- **cherrypick** (по умолчанию)
- **get_it**
- Легко добавить свой DI через DIAdapter
Меняется одной CLI-опцией: `--di`
---
## Как запустить
1. **Установить зависимости:**
```shell
dart pub get
```
2. **Запустить все бенчмарки (по умолчанию: все сценарии, 2 прогрева, 2 замера):**
```shell
dart run bin/main.dart --benchmark=all --format=markdown
```
3. **Для get_it:**
```shell
dart run bin/main.dart --di=getit --benchmark=all --format=markdown
```
4. **Показать все опции CLI:**
```shell
dart run bin/main.dart --help
```
### Параметры CLI
- `--di` — Какой DI использовать: `cherrypick` (по умолчанию) или `getit`
- `--benchmark, -b` — Сценарий: `registerSingleton`, `chainSingleton`, `chainFactory`, `asyncChain`, `named`, `override`, `all`
- `--chainCount, -c` — Сколько параллельных цепочек (например, `10,100`)
- `--nestingDepth, -d` — Глубина цепочки (например, `5,10`)
- `--repeat, -r` — Повторов замера (по умолчанию 2)
- `--warmup, -w` — Прогревочных запусков (по умолчанию 1)
- `--format, -f` — Формат отчёта: `pretty`, `csv`, `json`, `markdown`
- `--help, -h` — Справка
### Примеры запуска
- **Все бенчмарки для cherrypick:**
```shell
dart run bin/main.dart --di=cherrypick --benchmark=all --format=markdown
```
- **Для get_it (все сценарии):**
```shell
dart run bin/main.dart --di=getit --benchmark=all --format=markdown
```
- **Запуск по матрице параметров:**
```shell
dart run bin/main.dart --benchmark=chainSingleton --chainCount=10,100 --nestingDepth=5,10 --repeat=3 --format=csv
```
---
## Как добавить свой DI
1. Реализуйте класс-адаптер, реализующий `DIAdapter` (`lib/di_adapters/ваш_adapter.dart`)
2. Зарегистрируйте его в CLI (`cli/benchmark_cli.dart`)
3. Дополните универсальную функцию регистрации (`di_universal_registration.dart`), чтобы строить цепочки для вашего DI
---
## Архитектура
```mermaid
classDiagram
class BenchmarkCliRunner {
+run(args)
}
class UniversalChainBenchmark {
+setup()
+run()
+teardown()
}
class UniversalChainAsyncBenchmark {
+setup()
+run()
+teardown()
}
class DIAdapter {
<<interface>>
+setupDependencies(cb)
+resolve<T>(named)
+resolveAsync<T>(named)
+teardown()
+openSubScope(name)
+waitForAsyncReady()
}
class CherrypickDIAdapter
class GetItAdapter
class UniversalChainModule {
+builder(scope)
+chainCount
+nestingDepth
+bindingMode
+scenario
}
class UniversalService {
<<interface>>
+value
+dependency
}
class UniversalServiceImpl {
+UniversalServiceImpl(value, dependency)
}
class di_universal_registration {
+getUniversalRegistration(adapter, ...)
}
class Scope
class UniversalScenario
class UniversalBindingMode
%% Relationships
BenchmarkCliRunner --> UniversalChainBenchmark
BenchmarkCliRunner --> UniversalChainAsyncBenchmark
UniversalChainBenchmark *-- DIAdapter
UniversalChainAsyncBenchmark *-- DIAdapter
DIAdapter <|.. CherrypickDIAdapter
DIAdapter <|.. GetItAdapter
CherrypickDIAdapter ..> Scope
GetItAdapter ..> GetIt: "uses GetIt"
DIAdapter o--> UniversalChainModule : setupDependencies
UniversalChainModule ..> UniversalScenario
UniversalChainModule ..> UniversalBindingMode
UniversalChainModule o-- UniversalServiceImpl : creates
UniversalService <|.. UniversalServiceImpl
UniversalServiceImpl --> UniversalService : dependency
BenchmarkCliRunner ..> di_universal_registration : uses
di_universal_registration ..> DIAdapter
UniversalChainBenchmark ..> di_universal_registration : uses registrar
UniversalChainAsyncBenchmark ..> di_universal_registration : uses registrar
```
---
## Метрики
Всегда собираются:
- **Время** (мкс): среднее, медиана, stddev, min, max
- **Память**: прирост RSS, пиковое значение RSS
## Лицензия
MIT

34
benchmark_di/analysis_options.yaml Normal file
View File

@@ -0,0 +1,34 @@
# This file configures the static analysis results for your project (errors,
# warnings, and lints).
#
# This enables the 'recommended' set of lints from `package:lints`.
# This set helps identify many issues that may lead to problems when running
# or consuming Dart code, and enforces writing Dart using a single, idiomatic
# style and format.
#
# If you want a smaller set of lints you can change this to specify
# 'package:lints/core.yaml'. These are just the most critical lints
# (the recommended set includes the core lints).
# The core lints are also what is used by pub.dev for scoring packages.
include: package:lints/recommended.yaml
analyzer:
errors:
deprecated_member_use: ignore
depend_on_referenced_packages: ignore
# Uncomment the following section to specify additional rules.
# linter:
# rules:
# - camel_case_types
# analyzer:
# exclude:
# - path/to/excluded/files/**
# For more information about the core and recommended set of lints, see
# https://dart.dev/go/core-lints
# For additional information about configuring this file, see
# https://dart.dev/guides/language/analysis-options

5
benchmark_di/bin/main.dart Normal file
View File

@@ -0,0 +1,5 @@
import 'package:benchmark_di/cli/benchmark_cli.dart';
Future<void> main(List<String> args) async {
await BenchmarkCliRunner().run(args);
}

42
benchmark_di/lib/benchmarks/universal_chain_async_benchmark.dart Normal file
View File

@@ -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);
}
}

82
benchmark_di/lib/benchmarks/universal_chain_benchmark.dart Normal file
View File

@@ -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');
}
}
}

85
benchmark_di/lib/cli/benchmark_cli.dart Normal file
View File

@@ -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));
}
}

129
benchmark_di/lib/cli/parser.dart Normal file
View File

@@ -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',
);
}

24
benchmark_di/lib/cli/report/csv_report.dart Normal file
View File

@@ -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');
}
}

13
benchmark_di/lib/cli/report/json_report.dart Normal file
View File

@@ -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]';
}
}

78
benchmark_di/lib/cli/report/markdown_report.dart Normal file
View File

@@ -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')}' ;
}
}

50
benchmark_di/lib/cli/report/pretty_report.dart Normal file
View File

@@ -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');
}
}

9
benchmark_di/lib/cli/report/report_generator.dart Normal file
View File

@@ -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;
}

96
benchmark_di/lib/cli/runner.dart Normal file
View File

@@ -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);
}
}

65
benchmark_di/lib/di_adapters/cherrypick_adapter.dart Normal file
View File

@@ -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));
}
}

24
benchmark_di/lib/di_adapters/di_adapter.dart Normal file
View File

@@ -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();
}

32
benchmark_di/lib/di_adapters/get_it_adapter.dart Normal file
View File

@@ -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();
}
}

109
benchmark_di/lib/scenarios/di_universal_registration.dart Normal file
View File

@@ -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}');
}

147
benchmark_di/lib/scenarios/universal_chain_module.dart Normal file
View File

@@ -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;
}
}
}

17
benchmark_di/lib/scenarios/universal_service.dart Normal file
View File

@@ -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});
}

16
benchmark_di/melos_benchmark_cherrypick.iml Normal file
View File

@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="WEB_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
<excludeFolder url="file://$MODULE_DIR$/.dart_tool" />
<excludeFolder url="file://$MODULE_DIR$/.pub" />
<excludeFolder url="file://$MODULE_DIR$/build" />
</content>
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="Dart SDK" level="project" />
<orderEntry type="library" name="Dart Packages" level="project" />
</component>
</module>

100
benchmark_di/pubspec.lock Normal file
View File

@@ -0,0 +1,100 @@
# Generated by pub
# See https://dart.dev/tools/pub/glossary#lockfile
packages:
ansi_modifier:
dependency: transitive
description:
name: ansi_modifier
sha256: "4b97c241f345e49c929bd56d0198b567b7dfcca7ec8d4f798745c9ced998684c"
url: "https://pub.dev"
source: hosted
version: "0.1.4"
args:
dependency: "direct main"
description:
name: args
sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
url: "https://pub.dev"
source: hosted
version: "2.7.0"
async:
dependency: transitive
description:
name: async
sha256: "758e6d74e971c3e5aceb4110bfd6698efc7f501675bcfe0c775459a8140750eb"
url: "https://pub.dev"
source: hosted
version: "2.13.0"
benchmark_harness:
dependency: "direct dev"
description:
name: benchmark_harness
sha256: "83f65107165883ba8623eb822daacb23dcf9f795c66841de758c9dd7c5a0cf28"
url: "https://pub.dev"
source: hosted
version: "2.3.1"
benchmark_runner:
dependency: "direct dev"
description:
name: benchmark_runner
sha256: "7de181228eb74cb34507ded2260fe88b3b71e0aacfe0dfa794df49edaf041ca3"
url: "https://pub.dev"
source: hosted
version: "0.0.4"
cherrypick:
dependency: "direct main"
description:
path: "../cherrypick"
relative: true
source: path
version: "3.0.0-dev.2"
collection:
dependency: transitive
description:
name: collection
sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
url: "https://pub.dev"
source: hosted
version: "1.19.1"
exception_templates:
dependency: transitive
description:
name: exception_templates
sha256: "517f7c770da690073663f867ee2057ae2f4ffb28edae9da9faa624aa29ac76eb"
url: "https://pub.dev"
source: hosted
version: "0.3.1"
get_it:
dependency: "direct main"
description:
name: get_it
sha256: a4292e7cf67193f8e7c1258203104eb2a51ec8b3a04baa14695f4064c144297b
url: "https://pub.dev"
source: hosted
version: "8.2.0"
lazy_memo:
dependency: transitive
description:
name: lazy_memo
sha256: dcb30b4184a6d767e1d779d74ce784d752d38313b8fb4bad6b659ae7af4bb34d
url: "https://pub.dev"
source: hosted
version: "0.2.3"
lints:
dependency: "direct dev"
description:
name: lints
sha256: c35bb79562d980e9a453fc715854e1ed39e24e7d0297a880ef54e17f9874a9d7
url: "https://pub.dev"
source: hosted
version: "5.1.1"
meta:
dependency: transitive
description:
name: meta
sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394"
url: "https://pub.dev"
source: hosted
version: "1.17.0"
sdks:
dart: ">=3.6.0 <4.0.0"

18
benchmark_di/pubspec.yaml Normal file
View File

@@ -0,0 +1,18 @@
name: benchmark_di
version: 0.1.0
publish_to: none
description: Universal benchmark for any DI library (cherrypick, get_it, and others)
environment:
sdk: '>=3.0.0 <4.0.0'
dependencies:
cherrypick:
path: ../cherrypick
args: ^2.7.0
get_it: ^8.2.0
dev_dependencies:
lints: ^5.0.0
benchmark_harness: ^2.2.2
benchmark_runner: ^0.0.2