Sizing хранилища

<?php

declare(strict_types=1);

/**
 * Storage sizing calculator: raw data -> total with indexes/replication/backup.
 */
final class StorageSizing
{
    public function __construct(
        private readonly int $objectCount,
        private readonly int $avgSizeBytes,
        private readonly float $indexOverhead = 0.3,   // 30% typical
        private readonly int $replicationFactor = 3,
        private readonly float $backupOverhead = 0.5,  // 50% for weekly+daily backups
        private readonly float $compressionRatio = 1.0, // 1.0 = no compression
    ) {}

    /**
     * @return array{
     *     raw: int, compressed: int, with_indexes: int,
     *     replicated: int, with_backups: int, total: int
     * }
     */
    public function estimate(): array
    {
        $raw = $this->objectCount * $this->avgSizeBytes;
        $compressed = (int) ($raw / $this->compressionRatio);
        $withIndexes = (int) ($compressed * (1 + $this->indexOverhead));
        $replicated = $withIndexes * $this->replicationFactor;
        $withBackups = (int) ($replicated * (1 + $this->backupOverhead));

        return [
            'raw'          => $raw,
            'compressed'   => $compressed,
            'with_indexes' => $withIndexes,
            'replicated'   => $replicated,
            'with_backups' => $withBackups,
            'total'        => $withBackups,
        ];
    }

    /**
     * Project growth over N years with given yearly multiplier.
     */
    public function projectGrowth(int $years, float $yearlyMultiplier = 2.0): int
    {
        $base = $this->estimate()['total'];
        return (int) ($base * ($yearlyMultiplier ** $years));
    }
}

// Usage:
// $s = new StorageSizing(
//     objectCount: 500_000_000,  // 500M tweets/day
//     avgSizeBytes: 580,
//     compressionRatio: 5.0,
//     replicationFactor: 3,
// );
// $daily = $s->estimate();
// $fiveYear = $s->projectGrowth(5, 1.5);

package storage

import "math"

// SizingParams holds inputs for capacity planning.
type SizingParams struct {
	ObjectCount       int64
	AvgSizeBytes      int64
	IndexOverhead     float64 // 0.3 = 30%
	ReplicationFactor int
	BackupOverhead    float64 // 0.5 = 50%
	CompressionRatio  float64 // 1.0 = no compression
}

// SizingResult breaks down storage components in bytes.
type SizingResult struct {
	Raw         int64
	Compressed  int64
	WithIndexes int64
	Replicated  int64
	WithBackups int64
	Total       int64
}

// Estimate computes the full storage breakdown.
func (p SizingParams) Estimate() SizingResult {
	raw := p.ObjectCount * p.AvgSizeBytes
	compression := p.CompressionRatio
	if compression < 1 {
		compression = 1
	}
	compressed := int64(float64(raw) / compression)
	withIndexes := int64(float64(compressed) * (1 + p.IndexOverhead))
	replicated := withIndexes * int64(p.ReplicationFactor)
	withBackups := int64(float64(replicated) * (1 + p.BackupOverhead))

	return SizingResult{
		Raw:         raw,
		Compressed:  compressed,
		WithIndexes: withIndexes,
		Replicated:  replicated,
		WithBackups: withBackups,
		Total:       withBackups,
	}
}

// ProjectGrowth extrapolates total storage over N years.
func (p SizingParams) ProjectGrowth(years int, yearlyMultiplier float64) int64 {
	base := p.Estimate().Total
	return int64(float64(base) * math.Pow(yearlyMultiplier, float64(years)))
}

using System;

// Storage breakdown in bytes.
public readonly record struct SizingResult(
    long Raw,
    long Compressed,
    long WithIndexes,
    long Replicated,
    long WithBackups)
{
    public long Total => WithBackups;
}

// Storage sizing calculator: raw data -> total with indexes/replication/backup.
public sealed class StorageSizing(
    long objectCount,
    long avgSizeBytes,
    double indexOverhead = 0.3,      // 30% typical
    int replicationFactor = 3,
    double backupOverhead = 0.5,     // 50% for weekly + daily backups
    double compressionRatio = 1.0)   // 1.0 = no compression
{
    public SizingResult Estimate()
    {
        var raw = objectCount * avgSizeBytes;
        var compression = Math.Max(1.0, compressionRatio);

        var compressed = (long)(raw / compression);
        var withIndexes = (long)(compressed * (1 + indexOverhead));
        var replicated = withIndexes * replicationFactor;
        var withBackups = (long)(replicated * (1 + backupOverhead));

        return new SizingResult(raw, compressed, withIndexes, replicated, withBackups);
    }

    // Project growth over N years with the given yearly multiplier.
    public long ProjectGrowth(int years, double yearlyMultiplier = 2.0) =>
        (long)(Estimate().Total * Math.Pow(yearlyMultiplier, years));
}

// Usage:
// var s = new StorageSizing(
//     objectCount: 500_000_000,   // 500M tweets/day
//     avgSizeBytes: 580,
//     compressionRatio: 5.0,
//     replicationFactor: 3);
// var daily = s.Estimate();
// var fiveYear = s.ProjectGrowth(5, 1.5);

from __future__ import annotations

from dataclasses import dataclass

@dataclass(frozen=True, slots=True)
class SizingResult:
    """Storage breakdown in bytes."""

    raw: int
    compressed: int
    with_indexes: int
    replicated: int
    with_backups: int

    @property
    def total(self) -> int:
        return self.with_backups

@dataclass(frozen=True, slots=True)
class StorageSizing:
    """Storage sizing: raw data -> total with indexes/replication/backup."""

    object_count: int
    avg_size_bytes: int
    index_overhead: float = 0.3       # 30% typical
    replication_factor: int = 3
    backup_overhead: float = 0.5      # 50% for weekly + daily backups
    compression_ratio: float = 1.0    # 1.0 = no compression

    def estimate(self) -> SizingResult:
        raw = self.object_count * self.avg_size_bytes
        compression = max(1.0, self.compression_ratio)

        compressed = int(raw / compression)
        with_indexes = int(compressed * (1 + self.index_overhead))
        replicated = with_indexes * self.replication_factor
        with_backups = int(replicated * (1 + self.backup_overhead))

        return SizingResult(raw, compressed, with_indexes, replicated, with_backups)

    def project_growth(self, years: int, yearly_multiplier: float = 2.0) -> int:
        """Project growth over N years with the given yearly multiplier."""
        return int(self.estimate().total * (yearly_multiplier ** years))

# Usage:
# s = StorageSizing(
#     object_count=500_000_000,   # 500M tweets/day
#     avg_size_bytes=580,
#     compression_ratio=5.0,
#     replication_factor=3,
# )
# daily = s.estimate()
# five_year = s.project_growth(5, 1.5)