Расчёт QPS и RPS

<?php

declare(strict_types=1);

/**
 * QPS estimator: DAU + actions -> average/peak QPS with read/write split.
 */
final class QpsEstimator
{
    private const SECONDS_PER_DAY = 86_400;

    public function __construct(
        private readonly int $dau,
        private readonly int $actionsPerUser,
        private readonly int $readWriteRatio = 100, // reads per 1 write
        private readonly float $peakMultiplier = 3.0,
    ) {}

    /**
     * @return array{
     *     avg: float, peak: float,
     *     read_avg: float, read_peak: float,
     *     write_avg: float, write_peak: float
     * }
     */
    public function estimate(): array
    {
        $totalActions = $this->dau * $this->actionsPerUser;
        $avg = $totalActions / self::SECONDS_PER_DAY;
        $peak = $avg * $this->peakMultiplier;

        $readShare  = $this->readWriteRatio / ($this->readWriteRatio + 1);
        $writeShare = 1 / ($this->readWriteRatio + 1);

        return [
            'avg'        => round($avg, 1),
            'peak'       => round($peak, 1),
            'read_avg'   => round($avg  * $readShare, 1),
            'read_peak'  => round($peak * $readShare, 1),
            'write_avg'  => round($avg  * $writeShare, 1),
            'write_peak' => round($peak * $writeShare, 1),
        ];
    }

    /**
     * DB-level QPS given amplification factor (1 HTTP req -> N DB queries).
     */
    public function dbQps(int $amplificationRead, int $amplificationWrite): array
    {
        $e = $this->estimate();
        return [
            'db_read_peak'  => round($e['read_peak']  * $amplificationRead, 1),
            'db_write_peak' => round($e['write_peak'] * $amplificationWrite, 1),
        ];
    }
}

// Usage:
// $est = new QpsEstimator(dau: 10_000_000, actionsPerUser: 10);
// $est->estimate();
// => ['avg' => 1157, 'peak' => 3472, 'read_peak' => 3437, 'write_peak' => 34, ...]

package qps

import "math"

const secondsPerDay = 86_400

// Estimator computes QPS from DAU and activity parameters.
type Estimator struct {
	DAU             int
	ActionsPerUser  int
	ReadWriteRatio  int     // reads per 1 write
	PeakMultiplier  float64 // peak/avg
}

// Result holds the estimation breakdown.
type Result struct {
	Avg       float64
	Peak      float64
	ReadAvg   float64
	ReadPeak  float64
	WriteAvg  float64
	WritePeak float64
}

// Estimate returns average and peak QPS split by read/write.
func (e Estimator) Estimate() Result {
	total := float64(e.DAU) * float64(e.ActionsPerUser)
	avg := total / secondsPerDay
	peak := avg * e.PeakMultiplier

	ratio := float64(e.ReadWriteRatio)
	readShare := ratio / (ratio + 1)
	writeShare := 1.0 / (ratio + 1)

	return Result{
		Avg:       math.Round(avg*10) / 10,
		Peak:      math.Round(peak*10) / 10,
		ReadAvg:   math.Round(avg*readShare*10) / 10,
		ReadPeak:  math.Round(peak*readShare*10) / 10,
		WriteAvg:  math.Round(avg*writeShare*10) / 10,
		WritePeak: math.Round(peak*writeShare*10) / 10,
	}
}

// DBQps applies request-to-DB amplification factors.
func (e Estimator) DBQps(ampRead, ampWrite int) (readPeak, writePeak float64) {
	r := e.Estimate()
	return r.ReadPeak * float64(ampRead), r.WritePeak * float64(ampWrite)
}

using System;

// Estimation breakdown: average and peak QPS split by read/write.
public readonly record struct QpsResult(
    double Avg,
    double Peak,
    double ReadAvg,
    double ReadPeak,
    double WriteAvg,
    double WritePeak);

// QPS estimator: DAU + actions -> average/peak QPS with read/write split.
public sealed class QpsEstimator(
    long dau,
    int actionsPerUser,
    int readWriteRatio = 100,   // reads per 1 write
    double peakMultiplier = 3.0)
{
    private const int SecondsPerDay = 86_400;

    public QpsResult Estimate()
    {
        var totalActions = (double)dau * actionsPerUser;
        var avg = totalActions / SecondsPerDay;
        var peak = avg * peakMultiplier;

        var readShare = (double)readWriteRatio / (readWriteRatio + 1);
        var writeShare = 1.0 / (readWriteRatio + 1);

        return new QpsResult(
            Avg: Math.Round(avg, 1),
            Peak: Math.Round(peak, 1),
            ReadAvg: Math.Round(avg * readShare, 1),
            ReadPeak: Math.Round(peak * readShare, 1),
            WriteAvg: Math.Round(avg * writeShare, 1),
            WritePeak: Math.Round(peak * writeShare, 1));
    }

    // DB-level QPS given amplification (1 HTTP request -> N DB queries).
    public (double ReadPeak, double WritePeak) DbQps(int amplificationRead, int amplificationWrite)
    {
        var e = Estimate();
        return (
            Math.Round(e.ReadPeak * amplificationRead, 1),
            Math.Round(e.WritePeak * amplificationWrite, 1));
    }
}

// Usage:
// var est = new QpsEstimator(dau: 10_000_000, actionsPerUser: 10);
// est.Estimate(); // Avg 1157, Peak 3472, ReadPeak 3437, WritePeak 34

from __future__ import annotations

from dataclasses import dataclass

SECONDS_PER_DAY = 86_400

@dataclass(frozen=True, slots=True)
class QpsResult:
    """Average and peak QPS split by read/write."""

    avg: float
    peak: float
    read_avg: float
    read_peak: float
    write_avg: float
    write_peak: float

@dataclass(frozen=True, slots=True)
class QpsEstimator:
    """QPS estimator: DAU + actions -> average/peak QPS with read/write split."""

    dau: int
    actions_per_user: int
    read_write_ratio: int = 100   # reads per 1 write
    peak_multiplier: float = 3.0

    def estimate(self) -> QpsResult:
        total_actions = self.dau * self.actions_per_user
        avg = total_actions / SECONDS_PER_DAY
        peak = avg * self.peak_multiplier

        read_share = self.read_write_ratio / (self.read_write_ratio + 1)
        write_share = 1 / (self.read_write_ratio + 1)

        return QpsResult(
            avg=round(avg, 1),
            peak=round(peak, 1),
            read_avg=round(avg * read_share, 1),
            read_peak=round(peak * read_share, 1),
            write_avg=round(avg * write_share, 1),
            write_peak=round(peak * write_share, 1),
        )

    def db_qps(self, amplification_read: int, amplification_write: int) -> tuple[float, float]:
        """DB-level QPS given amplification (1 HTTP request -> N DB queries)."""
        e = self.estimate()
        return (
            round(e.read_peak * amplification_read, 1),
            round(e.write_peak * amplification_write, 1),
        )

# Usage:
# est = QpsEstimator(dau=10_000_000, actions_per_user=10)
# est.estimate()
# # QpsResult(avg=1157.4, peak=3472.2, read_peak=3437.8, write_peak=34.4, ...)