Обзор основ Computer Science

<?php

declare(strict_types=1);

/**
 * Understanding hardware helps make better architectural decisions.
 *
 * This class demonstrates how knowledge of memory hierarchy
 * influences caching strategy design.
 */
final class PerformanceAwareService
{
    /** @var array<string, mixed> */
    private array $localCache = [];

    public function __construct(
        private readonly RedisConnection $redis,
        private readonly DatabaseConnection $db,
    ) {}

    /**
     * Multi-level caching mirrors hardware memory hierarchy:
     * L1 (in-process array) -> L2 (Redis/RAM) -> L3 (Database/Disk)
     */
    public function getData(string $key): mixed
    {
        // Level 1: In-process cache (~nanoseconds)
        // Like CPU L1 cache - fastest, smallest
        if (isset($this->localCache[$key])) {
            return $this->localCache[$key];
        }

        // Level 2: Redis cache (~microseconds, network hop)
        // Like RAM - fast, limited by memory
        $cached = $this->redis->get($key);
        if ($cached !== null) {
            $this->localCache[$key] = $cached;
            return $cached;
        }

        // Level 3: Database (~milliseconds, disk I/O)
        // Like HDD - slow, virtually unlimited
        $data = $this->db->query(
            'SELECT data FROM cache_table WHERE key = :key',
            ['key' => $key],
        );

        if ($data !== null) {
            $this->redis->set($key, $data, ttl: 3600);
            $this->localCache[$key] = $data;
        }

        return $data;
    }
}

package cache

import (
	"context"
	"database/sql"
	"sync"
	"time"
)

// PerformanceAwareService demonstrates how knowledge of memory hierarchy
// influences caching strategy design.
type PerformanceAwareService struct {
	mu         sync.RWMutex
	localCache map[string]any
	redis      RedisConnection
	db         *sql.DB
}

func NewPerformanceAwareService(redis RedisConnection, db *sql.DB) *PerformanceAwareService {
	return &PerformanceAwareService{
		localCache: make(map[string]any),
		redis:      redis,
		db:         db,
	}
}

// GetData mirrors hardware memory hierarchy:
// L1 (in-process map) -> L2 (Redis/RAM) -> L3 (Database/Disk)
func (s *PerformanceAwareService) GetData(ctx context.Context, key string) (any, error) {
	// Level 1: In-process cache (~nanoseconds)
	// Like CPU L1 cache - fastest, smallest
	s.mu.RLock()
	if val, ok := s.localCache[key]; ok {
		s.mu.RUnlock()
		return val, nil
	}
	s.mu.RUnlock()

	// Level 2: Redis cache (~microseconds, network hop)
	// Like RAM - fast, limited by memory
	cached, err := s.redis.Get(ctx, key)
	if err == nil && cached != nil {
		s.mu.Lock()
		s.localCache[key] = cached
		s.mu.Unlock()
		return cached, nil
	}

	// Level 3: Database (~milliseconds, disk I/O)
	// Like HDD - slow, virtually unlimited
	var data string
	err = s.db.QueryRowContext(ctx,
		"SELECT data FROM cache_table WHERE key = $1", key,
	).Scan(&data)
	if err != nil {
		return nil, err
	}

	_ = s.redis.Set(ctx, key, data, 3600*time.Second)
	s.mu.Lock()
	s.localCache[key] = data
	s.mu.Unlock()

	return data, nil
}

using System.Data.Common;

namespace Foundations.Caching;

/// <summary>
/// Demonstrates how knowledge of the memory hierarchy
/// influences caching strategy design.
/// </summary>
public sealed class PerformanceAwareService
{
    private readonly Dictionary<string, object?> _localCache = new();
    private readonly SemaphoreSlim _gate = new(1, 1);
    private readonly IRedisConnection _redis;
    private readonly DbConnection _db;

    public PerformanceAwareService(IRedisConnection redis, DbConnection db)
    {
        _redis = redis;
        _db = db;
    }

    /// <summary>
    /// Mirrors the hardware memory hierarchy:
    /// L1 (in-process dictionary) -> L2 (Redis/RAM) -> L3 (Database/Disk)
    /// </summary>
    public async Task<object?> GetDataAsync(string key, CancellationToken ct = default)
    {
        // Level 1: In-process cache (~nanoseconds)
        // Like CPU L1 cache - fastest, smallest
        await _gate.WaitAsync(ct);
        try
        {
            if (_localCache.TryGetValue(key, out var local))
            {
                return local;
            }
        }
        finally
        {
            _gate.Release();
        }

        // Level 2: Redis cache (~microseconds, network hop)
        // Like RAM - fast, limited by memory
        var cached = await _redis.GetAsync(key, ct);
        if (cached is not null)
        {
            await StoreLocalAsync(key, cached, ct);
            return cached;
        }

        // Level 3: Database (~milliseconds, disk I/O)
        // Like HDD - slow, virtually unlimited
        await using var command = _db.CreateCommand();
        command.CommandText = "SELECT data FROM cache_table WHERE key = @key";
        var parameter = command.CreateParameter();
        parameter.ParameterName = "@key";
        parameter.Value = key;
        command.Parameters.Add(parameter);

        var data = await command.ExecuteScalarAsync(ct);
        if (data is not null)
        {
            await _redis.SetAsync(key, data, TimeSpan.FromSeconds(3600), ct);
            await StoreLocalAsync(key, data, ct);
        }

        return data;
    }

    private async Task StoreLocalAsync(string key, object value, CancellationToken ct)
    {
        await _gate.WaitAsync(ct);
        try
        {
            _localCache[key] = value;
        }
        finally
        {
            _gate.Release();
        }
    }
}

from __future__ import annotations

import threading
from typing import Any

import redis
from psycopg import Connection

class PerformanceAwareService:
    """Shows how knowledge of the memory hierarchy shapes caching strategy."""

    def __init__(self, cache: redis.Redis, db: Connection) -> None:
        self._local_cache: dict[str, Any] = {}
        self._lock = threading.Lock()
        self._cache = cache
        self._db = db

    def get_data(self, key: str) -> Any | None:
        """Mirrors the hardware memory hierarchy.

        L1 (in-process dict) -> L2 (Redis/RAM) -> L3 (Database/Disk)
        """
        # Level 1: In-process cache (~nanoseconds)
        # Like CPU L1 cache - fastest, smallest
        with self._lock:
            if key in self._local_cache:
                return self._local_cache[key]

        # Level 2: Redis cache (~microseconds, network hop)
        # Like RAM - fast, limited by memory
        cached = self._cache.get(key)
        if cached is not None:
            with self._lock:
                self._local_cache[key] = cached
            return cached

        # Level 3: Database (~milliseconds, disk I/O)
        # Like HDD - slow, virtually unlimited
        with self._db.cursor() as cursor:
            cursor.execute("SELECT data FROM cache_table WHERE key = %s", (key,))
            row = cursor.fetchone()

        if row is None:
            return None

        data = row[0]
        self._cache.setex(key, 3600, data)
        with self._lock:
            self._local_cache[key] = data

        return data