엔드포인트별 p50/p95 지연 시간

FxDart 승

요구사항

원본 요청 로그(데이터는 코드에 있음)에서 실패한 요청을 제외하고, 엔드포인트별 p50 및 p95 지연 시간을 계산하세요: 각 엔드포인트의 지연 시간을 정렬한 뒤 인덱스 round((n-1) * q / 100)의 값을 취합니다. p95가 가장 나쁜 순서로 정렬된 표를 출력하고, 가장 나쁜 엔드포인트를 별도로 알려주세요. 두 버전 모두 예상 출력 아래에 표시된 표를 출력해야 합니다.

예상 출력

Latency percentiles (successful requests only)
  /orders  p50 133 ms  p95 620 ms  (5 reqs)
  /search  p50 210 ms  p95 480 ms  (4 reqs)
  /users   p50  88 ms  p95 340 ms  (5 reqs)
Worst p95: /orders at 620 ms

나란히 보기

네이티브 Dart

import 'package:collection/collection.dart';

class Req {
  final String endpoint;
  final int ms;
  final int status;
  const Req(this.endpoint, this.ms, this.status);
}

const reqs = [
  Req('/users', 82, 200),
  Req('/users', 74, 200),
  Req('/users', 96, 200),
  Req('/users', 340, 200),
  Req('/users', 88, 200),
  Req('/orders', 120, 200),
  Req('/orders', 145, 200),
  Req('/orders', 110, 200),
  Req('/orders', 620, 200),
  Req('/orders', 133, 200),
  Req('/search', 210, 200),
  Req('/search', 480, 200),
  Req('/search', 190, 200),
  Req('/search', 205, 200),
  Req('/orders', 30, 500),
  Req('/users', 12, 503),
];

void main() {
  final ok = reqs.where((r) => r.status == 200).toList();

final rows = <(String, int, int, int)>[];
  for (final e in ok.groupListsBy((r) => r.endpoint).entries) {
    final sorted = e.value.map((r) => r.ms).toList()..sort();
    int pct(int q) => sorted[((sorted.length - 1) * q / 100).round()];
    rows.add((e.key, pct(50), pct(95), sorted.length));
  }

final lines = rows.sortedBy<num>((r) => -r.$3).map((r) =>
      '  ${r.$1.padRight(8)} p50 ${'${r.$2}'.padLeft(3)} ms  '
      'p95 ${'${r.$3}'.padLeft(3)} ms  (${r.$4} reqs)');
  final worst = rows.reduce((a, b) => a.$3 >= b.$3 ? a : b);

print([
    'Latency percentiles (successful requests only)',
    ...lines,
    'Worst p95: ${worst.$1} at ${worst.$3} ms',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Req {
  final String endpoint;
  final int ms;
  final int status;
  const Req(this.endpoint, this.ms, this.status);
}

void main() {
  final ok = fx(reqs).filter((r) => r.status == 200).toList();

final rows = fx(fx(ok).groupBy((r) => r.endpoint).entries).map((e) {
    final sorted = fx(e.value).map((r) => r.ms).sort((a, b) => a.compareTo(b)).toList();
    int pct(int q) => nth(((sorted.length - 1) * q / 100).round(), sorted)!;
    return (e.key, pct(50), pct(95), sorted.length);
  }).toList();

final lines = fx(rows).sortBy((r) => -r.$3).map((r) =>
      '  ${r.$1.padRight(8)} p50 ${'${r.$2}'.padLeft(3)} ms  '
      'p95 ${'${r.$3}'.padLeft(3)} ms  (${r.$4} reqs)');
  final worst = fx(rows).maxBy((r) => r.$3)!;

print(join('\n', [
    'Latency percentiles (successful requests only)',
    ...lines,
    'Worst p95: ${worst.$1} at ${worst.$3} ms',
  ]));
}

차이가 나는 이유

백분위수는 "정렬한 다음 인덱싱"입니다 — FxDart에서는 이것이 그대로 sortBy + nth이며, 각 엔드포인트 그룹을 통계 행으로 바꾸는 groupBy → map 파이프라인 안에 적용됩니다. 표를 순위별로 나열하고 가장 나쁜 엔드포인트를 찾는 부분도 같은 행들을 sortBy와 maxBy로 재사용합니다. 네이티브 버전은 같은 계산을 하지만 for 루프로 채우는 가변 행 리스트, 제자리 ..sort(), 원시 인덱스 접근, 최댓값을 위한 reduce 비교자를 거칩니다. 둘 다 정확하지만, fxdart 쪽은 "그룹화 → 요약 → 순위화"를 한 루프가 한꺼번에 처리하는 대신 눈에 보이는 세 번의 붓질로 유지합니다.

벤치마크

Apple M1 Max, RAM 32 GB · Dart 3.12.2 (AOT 컴파일) · 2026-08-24

N = 100

시간 무승부

네이티브 Dart 22 µs

FxDart 20 µs

최대 메모리 무승부

네이티브 Dart 16.6 MB

FxDart 16.5 MB

N = 10,000

시간 무승부

네이티브 Dart 1.93 ms

FxDart 1.80 ms

최대 메모리 FxDart 승

네이티브 Dart 18.1 MB

FxDart 17.3 MB

N = 1,000,000

시간 무승부

네이티브 Dart 204.7 ms

FxDart 209.7 ms

최대 메모리 네이티브 승

네이티브 Dart 139.4 MB

FxDart 192.2 MB

막대는 사이드별로 새 프로세스에서 반복 측정한 중앙값입니다(작은 N은 타이머 해상도를 위해 배치 처리). 두 사이드가 서로 5% 이내이거나 — 사람이 지각할 수 없는 차이인 0.6ms 이내이면 — 무승부로 칩니다. 상대 차이가 근소한 경우는 최대 5회까지 다시 측정합니다. 앱에서는 어느 막대가 짧든 몇 밀리초 이하의 차이는 사용자에게 보이지 않습니다. 메모리는 프로세스 최대 RSS입니다. Dart VM과 데이터셋은 양쪽이 동일하므로, 두 막대의 차이가 곧 파이프라인 자체가 붙들고 있는 양입니다.