Bandwidth и память

<?php

declare(strict_types=1);

/**
 * Bandwidth and memory sizing helpers.
 */
final class NetworkSizing
{
    /**
     * Compute outbound bandwidth in bytes/sec for API traffic.
     */
    public static function egressBytesPerSec(int $qps, int $avgResponseBytes): int
    {
        return $qps * $avgResponseBytes;
    }

    /**
     * Monthly egress cost in USD.
     * Default AWS rate: $0.09/GB for first 10TB, averaged for simplicity.
     */
    public static function monthlyEgressCost(
        int $qps,
        int $avgResponseBytes,
        float $cdnHitRatio = 0.0,
        float $costPerGb = 0.09,
    ): float {
        $secondsPerMonth = 30 * 86_400;
        $totalBytes = $qps * $avgResponseBytes * $secondsPerMonth;
        $originBytes = $totalBytes * (1 - $cdnHitRatio);
        $gb = $originBytes / (1024 ** 3);
        return round($gb * $costPerGb, 2);
    }

    /**
     * Gbps needed for given QPS/response size.
     */
    public static function requiredGbps(int $qps, int $avgResponseBytes): float
    {
        $bitsPerSec = $qps * $avgResponseBytes * 8;
        return round($bitsPerSec / 1e9, 2);
    }
}

/**
 * Cache sizing via Pareto / working set.
 */
final class CacheSizing
{
    /**
     * Estimate RAM needed to achieve target hit ratio under Zipf distribution.
     * Approximation: hit_ratio ≈ cache_share ^ 0.3 (heavy Zipf alpha ~0.8).
     */
    public static function ramForHitRatio(
        int $totalObjects,
        int $avgObjectBytes,
        float $targetHitRatio = 0.9,
    ): int {
        // Inverse of approximation: share = hit_ratio ^ (1/0.3)
        $cacheShare = $targetHitRatio ** (1 / 0.3);
        $cachedObjects = (int) ($totalObjects * $cacheShare);
        return $cachedObjects * $avgObjectBytes;
    }

    /**
     * Working set = hot objects × size.
     */
    public static function workingSetBytes(
        int $totalObjects,
        float $hotShare,
        int $avgObjectBytes,
    ): int {
        return (int) ($totalObjects * $hotShare * $avgObjectBytes);
    }
}

// Usage:
// NetworkSizing::requiredGbps(3000, 50*1024) => 1.23 (Gbps)
// CacheSizing::ramForHitRatio(100_000_000, 1024, 0.9) => ~700 GB

package network

import "math"

// EgressBytesPerSec returns outbound bandwidth for given QPS/response size.
func EgressBytesPerSec(qps int, avgRespBytes int) int64 {
	return int64(qps) * int64(avgRespBytes)
}

// MonthlyEgressCost estimates USD cost with optional CDN offload.
func MonthlyEgressCost(qps, avgRespBytes int, cdnHitRatio, costPerGB float64) float64 {
	const secondsPerMonth = 30 * 86_400
	total := float64(qps) * float64(avgRespBytes) * float64(secondsPerMonth)
	origin := total * (1 - cdnHitRatio)
	gb := origin / math.Pow(1024, 3)
	return math.Round(gb*costPerGB*100) / 100
}

// RequiredGbps for given QPS/response size.
func RequiredGbps(qps, avgRespBytes int) float64 {
	bitsPerSec := float64(qps) * float64(avgRespBytes) * 8
	return math.Round(bitsPerSec/1e9*100) / 100
}

// RAMForHitRatio approximates cache RAM to reach target hit ratio (Zipf alpha~0.8).
func RAMForHitRatio(totalObjects, avgObjectBytes int, targetHitRatio float64) int64 {
	cacheShare := math.Pow(targetHitRatio, 1.0/0.3)
	cachedObjects := int64(float64(totalObjects) * cacheShare)
	return cachedObjects * int64(avgObjectBytes)
}

// WorkingSet returns bytes needed to hold hot objects.
func WorkingSet(totalObjects int, hotShare float64, avgObjectBytes int) int64 {
	return int64(float64(totalObjects) * hotShare * float64(avgObjectBytes))
}

using System;

// Bandwidth sizing helpers.
public static class NetworkSizing
{
    private const long SecondsPerMonth = 30L * 86_400L;
    private const double BytesPerGb = 1024d * 1024d * 1024d;

    // Outbound bandwidth in bytes/sec for API traffic.
    public static long EgressBytesPerSec(int qps, int avgResponseBytes) =>
        (long)qps * avgResponseBytes;

    // Monthly egress cost in USD. Default AWS rate: $0.09/GB.
    public static decimal MonthlyEgressCost(
        int qps,
        int avgResponseBytes,
        double cdnHitRatio = 0.0,
        decimal costPerGb = 0.09m)
    {
        var totalBytes = (double)qps * avgResponseBytes * SecondsPerMonth;
        var originBytes = totalBytes * (1 - cdnHitRatio);
        var gb = (decimal)(originBytes / BytesPerGb);

        // decimal keeps money arithmetic exact.
        return Math.Round(gb * costPerGb, 2);
    }

    // Gbps needed for a given QPS/response size.
    public static double RequiredGbps(int qps, int avgResponseBytes) =>
        Math.Round((double)qps * avgResponseBytes * 8 / 1e9, 2);
}

// Cache sizing via Pareto / working set.
public static class CacheSizing
{
    // RAM needed to reach a target hit ratio under a Zipf distribution.
    // Approximation: hit_ratio ~= cache_share^0.3 (heavy Zipf, alpha ~0.8).
    public static long RamForHitRatio(long totalObjects, int avgObjectBytes, double targetHitRatio = 0.9)
    {
        var cacheShare = Math.Pow(targetHitRatio, 1.0 / 0.3);
        var cachedObjects = (long)(totalObjects * cacheShare);
        return cachedObjects * avgObjectBytes;
    }

    // Working set = hot objects x size.
    public static long WorkingSetBytes(long totalObjects, double hotShare, int avgObjectBytes) =>
        (long)(totalObjects * hotShare * avgObjectBytes);
}

// Usage:
// NetworkSizing.RequiredGbps(3000, 50 * 1024);              // 1.23 Gbps
// CacheSizing.RamForHitRatio(100_000_000, 1024, 0.9);       // ~700 GB

from __future__ import annotations

SECONDS_PER_MONTH = 30 * 86_400
BYTES_PER_GB = 1024 ** 3

def egress_bytes_per_sec(qps: int, avg_response_bytes: int) -> int:
    """Outbound bandwidth in bytes/sec for API traffic."""
    return qps * avg_response_bytes

def monthly_egress_cost(
    qps: int,
    avg_response_bytes: int,
    cdn_hit_ratio: float = 0.0,
    cost_per_gb: float = 0.09,
) -> float:
    """Monthly egress cost in USD. Default AWS rate: $0.09/GB."""
    total_bytes = qps * avg_response_bytes * SECONDS_PER_MONTH
    origin_bytes = total_bytes * (1 - cdn_hit_ratio)
    return round(origin_bytes / BYTES_PER_GB * cost_per_gb, 2)

def required_gbps(qps: int, avg_response_bytes: int) -> float:
    """Gbps needed for a given QPS/response size."""
    return round(qps * avg_response_bytes * 8 / 1e9, 2)

def ram_for_hit_ratio(
    total_objects: int,
    avg_object_bytes: int,
    target_hit_ratio: float = 0.9,
) -> int:
    """RAM needed to reach a target hit ratio under a Zipf distribution.

    Approximation: hit_ratio ~= cache_share ** 0.3 (heavy Zipf, alpha ~0.8).
    """
    cache_share = target_hit_ratio ** (1 / 0.3)
    return int(total_objects * cache_share) * avg_object_bytes

def working_set_bytes(total_objects: int, hot_share: float, avg_object_bytes: int) -> int:
    """Working set = hot objects x size."""
    return int(total_objects * hot_share * avg_object_bytes)

# Usage:
# required_gbps(3000, 50 * 1024)                   # 1.23 Gbps
# ram_for_hit_ratio(100_000_000, 1024, 0.9)        # ~700 GB