Максимальная производительность C#: Процессорный кэш

// Вариант 1: обход по строкам (высокая локальность)
for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
        sum += matrix[i, j];
 
// Вариант 2: обход по столбцам (низкая локальность)
for (int j = 0; j < N; j++)
    for (int i = 0; i < N; i++)
        sum += matrix[i, j];

const int BLOCK_SIZE = 32;
 
for (int i = 0; i < N; i += BLOCK_SIZE)
    for (int j = 0; j < N; j += BLOCK_SIZE)
        for (int bi = i; bi < Math.Min(i + BLOCK_SIZE, N); bi++)
            for (int bj = j; bj < Math.Min(j + BLOCK_SIZE, N); bj++)
                result[bi, bj] = matrix1[bi, bj] * matrix2[bi, bj];

// Плохо для кэша: список объектов
var itemsList = new List<DataItem>();
 
// Лучше для кэша: массив структур
var itemsArray = new DataStruct[size];

public class Counter
{
    public long count1;
    public long count2;
}
 
// Поток 1 инкрементирует count1
while (running)
    counter.count1++;
 
// Поток 2 инкрементирует count2
while (running)
    counter.count2++;

[StructLayout(LayoutKind.Explicit)]
public class PaddedCounter
{
    [FieldOffset(0)]
    public long count1;
    
    [FieldOffset(64)] // Начинаем новую кэш-линию (обычно 64 байта)
    public long count2;
}

using System.Runtime.CompilerServices;
 
public class BetterCounter
{
    public long count1;
    
    [CacheLineSize]
    public long count2;
}

public sealed class CacheFriendlyCounters
{
    private readonly CounterHolder[] _counters;
    
    public CacheFriendlyCounters(int numCounters)
    {
        _counters = new CounterHolder[numCounters];
        for (int i = 0; i < numCounters; i++)
            _counters[i] = new CounterHolder();
    }
    
    public void Increment(int index) => _counters[index].Count++;
    
    public long GetValue(int index) => _counters[index].Count;
    
    // Каждый экземпляр с большой вероятностью попадет в отдельную кэш-линию
    private class CounterHolder
    {
        public long Count;
        // Добавляем "пустое" поле, чтобы занять целую кэш-линию
        private readonly long[] _padding = new long[7]; // 7 * 8 = 56 байт, плюс 8 байт на Count
    }
}

// Неоптимальная структура с точки зрения кэша
struct BadGameEntity
{
    public string Name; // Редко используется в игровом цикле
    public Vector3 Position; // Часто используется
    public int Health; // Часто используется
    public string Description; // Редко используется
    public Vector3 Velocity; // Часто используется вместе с Position
}
 
// Оптимизированная структура
struct BetterGameEntity
{
    // Группируем часто используемые данные вместе
    public Vector3 Position;
    public Vector3 Velocity;
    public int Health;
    // Редко используемые данные в конце
    public string Name;
    public string Description;
}

// Традиционный подход (AoS)
struct Particle
{
    public Vector3 Position;
    public Vector3 Velocity;
    public float Mass;
    public float Lifetime;
}
Particle[] particles = new Particle[10000];
 
// Подход SoA
class ParticleSystem
{
    private Vector3[] positions;
    private Vector3[] velocities;
    private float[] masses;
    private float[] lifetimes;
    
    // При обновлении позиций нам нужны только два массива
    public void UpdatePositions(float deltaTime)
    {
        for (int i = 0; i < positions.Length; i++)
            positions[i] += velocities[i] * deltaTime;
    }
}

// Вместо одной большой структуры
class Character
{
    // Компонент для физики
    public Vector3 Position;
    public Vector3 Velocity;
    public float Mass;
    
    // Компонент для рендеринга
    public Mesh Mesh;
    public Material Material;
    public Matrix Transform;
    
    // Компонент для игровой логики
    public int Health;
    public int Mana;
    public List<Ability> Abilities;
}
 
// Используем композицию компонентов
class BetterCharacter
{
    public PhysicsComponent Physics { get; }
    public RenderComponent Render { get; }
    public GameplayComponent Gameplay { get; }
}

[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct CompactStruct
{
    public byte Flag;     // 1 байт
    public int Value;     // 4 байта
    public short Code;    // 2 байта
}

unsafe void ProcessData(Particle* particles, int count)
{
    for (int i = 0; i < count; i++)
    {
        // Прямой доступ к памяти без проверок границ и косвенных обращений
        particles[i].Position.X += particles[i].Velocity.X;
        particles[i].Position.Y += particles[i].Velocity.Y;
        particles[i].Position.Z += particles[i].Velocity.Z;
    }
}

private static readonly ObjectPool<StringBuilder> _stringBuilderPool = 
    new ObjectPool<StringBuilder>(() => new StringBuilder(1024), sb => sb.Clear());
 
public string FormatData(Data data)
{
    var sb = _stringBuilderPool.Get();
    try
    {
        // Использование StringBuilder
        return sb.ToString();
    }
    finally
    {
        _stringBuilderPool.Return(sb);
    }
}

// Вместо этого
byte[] buffer = new byte[4096];
ReadData(buffer);
 
// Используйте это
byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
try
{
    ReadData(buffer);
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

public int SumArray(ReadOnlySpan<int> data)
{
    int sum = 0;
    // Эффективный обход без дополнительных проверок границ
    // и с прекрасной локальностью в кэше
    for (int i = 0; i < data.Length; i++)
    {
        sum += data[i];
    }
    return sum;
}
 
// Можно вызывать с разными источниками данных
int[] array = new int[1000];
Span<int> stackAlloc = stackalloc int[128]; // Данные в стеке!
SumArray(array);
SumArray(stackAlloc);
SumArray(array.AsSpan(10, 100)); // Срез без копирования

unsafe void ProcessLargeArray(float* data, int length)
{
    const int PREFETCH_DISTANCE = 16; // Экспериментальное значение
    
    for (int i = 0; i < length; i++)
    {
        // Предзагружаем данные, которые понадобятся через несколько итераций
        if (i + PREFETCH_DISTANCE < length)
        {
            Prefetch.PrefetchNonTemporal(data + i + PREFETCH_DISTANCE);
        }
        
        // Обработка текущего элемента
        data[i] = ProcessItem(data[i]);
    }
}

[Benchmark]
[HardwareCounters(
    HardwareCounter.CacheMisses,
    HardwareCounter.BranchMispredictions,
    HardwareCounter.BranchInstructions)]
public void ProcessArray()
{
    // Код метода, который мы тестируем
}

// Вместо этого
Dictionary<int, string> userNames = new Dictionary<int, string>();
for (int i = 0; i < 1000; i++)
    userNames[i] = GetUserName(i);
 
// Используйте это, если ID компактны и начинаются с 0
string[] userNamesArray = new string[1000];
for (int i = 0; i < 1000; i++)
    userNamesArray[i] = GetUserName(i);

void ProcessHugeArray(float[] data)
{
    const int BLOCK_SIZE = 16384; // Размер блока, соответствующий кэшу
    for (int blockStart = 0; blockStart < data.Length; blockStart += BLOCK_SIZE)
    {
        int blockEnd = Math.Min(blockStart + BLOCK_SIZE, data.Length);
        ProcessBlock(data, blockStart, blockEnd);
    }
}
 
void ProcessBlock(float[] data, int start, int end)
{
    for (int i = start; i < end; i++)
    {
        data[i] = Transform(data[i]);
    }
}

// Неоптимально: сериализация отдельных объектов по одному
foreach (var item in items)
{
    string json = JsonSerializer.Serialize(item);
    await writer.WriteLineAsync(json);
}
 
// Лучше: агрегирование объектов и пакетная сериализация
var batch = items.Take(1000).ToArray();
string batchJson = JsonSerializer.Serialize(batch);
await writer.WriteLineAsync(batchJson);

// Лучше для десериализации в сценариях, где ID и Name используются чаще всего
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Далее идут реже используемые свойства
    public DateTime RegistrationDate { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
}

int CalculateOptimalBTreeDegree<T>()
{
    int cacheLineSize = 64; // Типичный размер кэш-линии
    int nodeOverhead = 16; // Примерный размер служебных полей узла
    int keySize = Marshal.SizeOf<T>(); // Размер ключа
    int pointerSize = IntPtr.Size; // Размер указателя (4 или 8 байт)
    
    // Максимальное количество ключей, которое влезает в одну кэш-линию
    int keysPerNode = (cacheLineSize - nodeOverhead) / (keySize + pointerSize);
    return Math.Max(2, keysPerNode); // Минимальная степень B-дерева - 2
}

// Атомарное увеличение счетчика
// Вызывает блокировку кэш-линии на уровне процессора
int value = Interlocked.Increment(ref counter);
 
// Атомарный обмен значениями с обеспечением когерентности кэша
int oldValue = Interlocked.Exchange(ref target, newValue);

// Вместо одного счетчика на всех
private long _globalCounter;
 
// Используем массив счетчиков — по одному на каждый поток
private long[] _threadLocalCounters;
 
// Каждый поток увеличивает свой счетчик без конфликтов
public void Increment()
{
    int threadId = Thread.CurrentThread.ManagedThreadId % _threadLocalCounters.Length;
    Interlocked.Increment(ref _threadLocalCounters[threadId]);
}
 
// Суммируем только когда нужен общий результат
public long GetTotalCount() => _threadLocalCounters.Sum();

// Неоптимально для кэша: загружаем полные сущности
var customers = dbContext.Customers
    .Where(c => c.Region == "North")
    .ToList();
 
foreach (var customer in customers)
{
    Console.WriteLine($"{customer.Id}: {customer.Name}");
}
 
// Лучше: проекция только нужных полей
var customerData = dbContext.Customers
    .Where(c => c.Region == "North")
    .Select(c => new { c.Id, c.Name })
    .ToList();

// Плохо: создаёт N+1 запросов и нарушает локальность
var orders = dbContext.Orders.ToList();
foreach (var order in orders)
{
    // Отдельный запрос для каждого заказа
    var customer = dbContext.Customers.Find(order.CustomerId);
    // Обработка...
}
 
// Лучше: загрузка всех данных за один запрос
var ordersWithCustomers = dbContext.Orders
    .Include(o => o.Customer)
    .ToList();

// Не нагружаем кэш избыточными данными
await foreach (var customer in dbContext.Customers
    .AsAsyncEnumerable())
{
    // Обрабатываем по одной записи
    // Предыдущие записи могут быть собраны GC
}

// Для запросов только на чтение отключаем отслеживание
var products = dbContext.Products
    .AsNoTracking()
    .Where(p => p.Category == "Electronics")
    .ToList();

// Матрица смежности: отлично для плотных графов и поиска смежности
// Хорошая локальность в кэше для последовательного обхода
bool[,] adjacencyMatrix = new bool[nodeCount, nodeCount];
 
// Список смежности: лучше для разреженных графов
// Худшая локальность при обходе графа
List<int>[] adjacencyList = new List<int>[nodeCount];

// Классическое дерево: узлы разбросаны по памяти
class TreeNode
{
    public int Value;
    public TreeNode Left;
    public TreeNode Right;
}
 
// Кэш-дружественное представление: узлы хранятся в массиве
class CacheFriendlyTree
{
    private readonly int[] _values;
    
    // Левый потомок узла i находится по индексу 2*i+1
    // Правый - по индексу 2*i+2
    public int GetLeftChild(int nodeIndex) => 2 * nodeIndex + 1;
    public int GetRightChild(int nodeIndex) => 2 * nodeIndex + 2;
}

// Традиционный ООП-подход (плохо для кэша)
class Enemy
{
    public Vector3 Position;
    public Quaternion Rotation;
    public float Health;
    public void Update() { /* ... */ }
}
 
// ECS-подход (лучше для кэша)
struct Position { public Vector3 Value; }
struct Rotation { public Quaternion Value; }
struct Health { public float Value; }
 
// Системы обрабатывают компоненты массово
void UpdatePositions(EntityQuery query)
{
    // Эффективно обрабатываем однотипные данные
    // с отличной локальностью
}

// Добавляем мониторинг HardwareCounters в middleware ASP.NET Core
app.Use(async (context, next) =>
{
    var hardwareCounters = new HardwareCounterHelper();
    hardwareCounters.Start();
    
    try
    {
        await next();
    }
    finally
    {
        var metrics = hardwareCounters.Stop();
        // Отправляем метрики в систему мониторинга
        context.Response.Headers.Add("X-Cache-Misses", metrics.CacheMisses.ToString());
    }
});

// Вместо передачи всей модели пользователя
public class User
{
    public Guid Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string FullName { get; set; }
    public DateTime RegistrationDate { get; set; }
    public string Address { get; set; }
    // Еще десятки полей
}
 
// Передаем только необходимый минимум для конкретной операции
public readonly struct UserIdentity
{
    public UserIdentity(Guid id, string username)
    {
        Id = id;
        Username = username;
    }
 
    public Guid Id { get; }
    public string Username { get; }
}

// Неэффективный подход: каждый раз создаем новые JsonSerializerOptions
app.MapPost("/api/data", (MyData data) =>
{
    var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
    return JsonSerializer.Serialize(data, options);
});
 
// Эффективный подход: повторно используем настройки сериализации
private static readonly JsonSerializerOptions _jsonOptions = new()
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
 
app.MapPost("/api/data", (MyData data) =>
{
    return JsonSerializer.Serialize(data, _jsonOptions);
});

// Оптимизация доступа к часто используемым заголовкам
public class OptimizedHeaders
{
    private readonly IHeaderDictionary _headers;
    
    // Кэшируем часто используемые значения
    private string _contentType;
    private string _authorization;
    
    public OptimizedHeaders(IHeaderDictionary headers)
    {
        _headers = headers;
        
        // Предзагружаем важные заголовки при создании
        headers.TryGetValue("Content-Type", out var contentType);
        _contentType = contentType.ToString();
        
        headers.TryGetValue("Authorization", out var auth);
        _authorization = auth.ToString();
    }
    
    public string ContentType => _contentType;
    public string Authorization => _authorization;
    
    // Для остальных заголовков используем исходный словарь
    public string GetHeader(string name) => _headers[name].ToString();
}

// Настраиваем второй уровень кэширования для EF Core
services.AddEntityFrameworkNpgsql()
    .AddDbContext<AppDbContext>((serviceProvider, options) =>
    {
        options.UseNpgsql(Configuration.GetConnectionString("Default"));
        options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
        
        // Добавляем кэширование запросов через надстройку
        options.UseEFSecondLevelCache(cacheOptions =>
        {
            cacheOptions.UseMemoryCacheProvider();
            cacheOptions.CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(10));
        });
    });

public class TimeSeriesAggregator<T>
{
    private readonly Dictionary<DateTime, List<T>> _buckets = new();
    private readonly TimeSpan _bucketSize;
    
    public TimeSeriesAggregator(TimeSpan bucketSize)
    {
        _bucketSize = bucketSize;
    }
    
    public void Add(DateTime timestamp, T value)
    {
        // Округляем временную метку до границы "ведра"
        var bucket = new DateTime(
            (timestamp.Ticks / _bucketSize.Ticks) * _bucketSize.Ticks,
            timestamp.Kind);
            
        if (!_buckets.TryGetValue(bucket, out var list))
        {
            list = new List<T>();
            _buckets[bucket] = list;
        }
        
        list.Add(value);
    }
    
    public IEnumerable<(DateTime Timestamp, TResult Result)> Aggregate<TResult>(
        Func<IEnumerable<T>, TResult> aggregator)
    {
        foreach (var (timestamp, values) in _buckets)
        {
            yield return (timestamp, aggregator(values));
        }
    }
}

// Неэффективная реализация скользящего окна
public IEnumerable<double> ComputeMovingAverage(double[] data, int windowSize)
{
    for (int i = 0; i <= data.Length - windowSize; i++)
    {
        double[] window = new double[windowSize];
        Array.Copy(data, i, window, 0, windowSize);
        yield return window.Average();
    }
}

// Кэш-эффективная реализация
public IEnumerable<double> ComputeMovingAverageBetter(double[] data, int windowSize)
{
    for (int i = 0; i <= data.Length - windowSize; i++)
    {
        ReadOnlySpan<double> window = data.AsSpan(i, windowSize);
        double sum = 0;
        for (int j = 0; j < window.Length; j++)
            sum += window[j];
        yield return sum / windowSize;
    }
}

// Традиционный подход с enum
enum UserPermissions
{
    Read = 1,
    Write = 2,
    Delete = 4,
    Admin = 8
}
 
// Проверка прав доступа
if (user.Permissions.HasFlag(UserPermissions.Write)) { /* ... */ }
 
// Более эффективный подход с битовыми операциями
const int PERM_READ = 1 << 0;   // 0001
const int PERM_WRITE = 1 << 1;  // 0010
const int PERM_DELETE = 1 << 2; // 0100
const int PERM_ADMIN = 1 << 3;  // 1000
 
// Проверка прав доступа
if ((user.PermissionBits & PERM_WRITE) != 0) { /* ... */ }

// Неоптимальная реализация k-means
void KMeansIteration(Point[] points, Point[] centroids)
{
    // Для каждой точки находим ближайший центроид
    foreach (var point in points)
    {
        int nearestCentroidIndex = 0;
        float minDistance = float.MaxValue;
        
        for (int i = 0; i < centroids.Length; i++)
        {
            float distance = CalculateDistance(point, centroids[i]);
            if (distance < minDistance)
            {
                minDistance = distance;
                nearestCentroidIndex = i;
            }
        }
        
        // Обновляем принадлежность точки кластеру
        point.ClusterIndex = nearestCentroidIndex;
    }
    
    // Пересчитываем центроиды кластеров...
}

void KMeansOptimized(Point[] points, Point[] centroids)
{
    const int BLOCK_SIZE = 256; // Подбирается экспериментально
    
    for (int blockStart = 0; blockStart < points.Length; blockStart += BLOCK_SIZE)
    {
        int blockEnd = Math.Min(blockStart + BLOCK_SIZE, points.Length);
        
        // Предзагружаем центроиды в кэш
        PrefetchCentroids(centroids);
        
        // Обрабатываем блок точек
        for (int i = blockStart; i < blockEnd; i++)
        {
            // Тот же алгоритм поиска ближайшего центроида
            // Но теперь центроиды с высокой вероятностью в кэше L1/L2
        }
    }
}

// Стандартное хранение эмбеддингов (32-битные числа)
float[,] wordEmbeddings = new float[vocabSize, embeddingDimension];
 
// Квантизованное хранение (8-битные числа + таблица масштабирования)
byte[,] quantizedEmbeddings = new byte[vocabSize, embeddingDimension];
float[] scalingFactors = new float[vocabSize];
 
// Квантизация
for (int i = 0; i < vocabSize; i++)
{
    float maxAbsValue = 0;
    for (int j = 0; j < embeddingDimension; j++)
        maxAbsValue = Math.Max(maxAbsValue, Math.Abs(wordEmbeddings[i, j]));
    
    scalingFactors[i] = maxAbsValue / 127; // Максимальное значение для byte
    
    for (int j = 0; j < embeddingDimension; j++)
        quantizedEmbeddings[i, j] = (byte)(wordEmbeddings[i, j] / scalingFactors[i]);
}

public void ParallelQuickSort<T>(T[] array, int parallelThreshold = 4096) where T : IComparable<T>
{
    void Sort(int left, int right, int depth)
    {
        // Если массив маленький или достигнута максимальная глубина рекурсии,
        // используем последовательную сортировку
        if (right - left <= parallelThreshold || depth <= 0)
        {
            Array.Sort(array, left, right - left + 1);
            return;
        }
        
        // Выбираем опорный элемент и разделяем массив
        int pivotIndex = Partition(array, left, right);
        
        // Сортируем подмассивы параллельно
        Parallel.Invoke(
            () => Sort(left, pivotIndex - 1, depth - 1),
            () => Sort(pivotIndex + 1, right, depth - 1)
        );
    }
    
    // Начинаем сортировку с максимальной глубиной рекурсии,
    // зависящей от количества ядер
    Sort(0, array.Length - 1, (int)Math.Log(Environment.ProcessorCount, 2) + 4);
}

// Кэш-оптимизированная пространственная хеш-таблица
public class SpatialHashGrid<T>
{
    private readonly Dictionary<Int64, List<T>> _cells = new();
    private readonly float _cellSize;
    
    public SpatialHashGrid(float cellSize)
    {
        _cellSize = cellSize;
    }
    
    // Хеш-функция для превращения 3D координат в 64-битный ключ
    private long GetKey(float x, float y, float z)
    {
        int xi = (int)Math.Floor(x / _cellSize);
        int yi = (int)Math.Floor(y / _cellSize);
        int zi = (int)Math.Floor(z / _cellSize);
        
        // Объединяем координаты в один 64-битный ключ
        return ((long)xi << 42) | ((long)yi << 21) | (long)zi;
    }
    
    // Добавляем объект в сетку
    public void Add(T item, float x, float y, float z)
    {
        long key = GetKey(x, y, z);
        if (!_cells.TryGetValue(key, out var list))
        {
            list = new List<T>();
            _cells[key] = list;
        }
        list.Add(item);
    }
    
    // Получаем все объекты в заданном радиусе
    public List<T> GetNearby(float x, float y, float z, float radius)
    {
        List<T> result = new();
        
        // Определяем границы поиска в ячейках
        int radiusCells = (int)Math.Ceiling(radius / _cellSize);
        int minXi = (int)Math.Floor((x - radius) / _cellSize);
        int maxXi = (int)Math.Floor((x + radius) / _cellSize);
        int minYi = (int)Math.Floor((y - radius) / _cellSize);
        int maxYi = (int)Math.Floor((y + radius) / _cellSize);
        int minZi = (int)Math.Floor((z - radius) / _cellSize);
        int maxZi = (int)Math.Floor((z + radius) / _cellSize);
        
        // Проверяем все ячейки в этом диапазоне
        for (int xi = minXi; xi <= maxXi; xi++)
            for (int yi = minYi; yi <= maxYi; yi++)
                for (int zi = minZi; zi <= maxZi; zi++)
                {
                    long key = ((long)xi << 42) | ((long)yi << 21) | (long)zi;
                    if (_cells.TryGetValue(key, out var list))
                        result.AddRange(list);
                }
        
        return result;
    }
}

// Создаём кэш-дружественное представление изображения
public unsafe class CacheOptimizedImage
{
  private readonly byte[] _data;
  private readonly int _width;
  private readonly int _height;
  private readonly int _stride;
  
  public CacheOptimizedImage(int width, int height)
  {
      _width = width;
      _height = height;
      // Выравниваем строки по границе кэш-линии (обычно 64 байта)
      _stride = (width * 3 + 63) & ~63;
      _data = new byte[_stride * height];
  }
  
  public void ApplyBlur(int radius)
  {
      fixed (byte* ptr = _data)
      {
          // Обрабатываем данные блоками для лучшей локальности
          const int BLOCK_SIZE = 32;
          for (int y = 0; y < _height; y += BLOCK_SIZE)
          {
              for (int x = 0; x < _width; x += BLOCK_SIZE)
              {
                  BlurBlock(ptr, x, y, 
                     Math.Min(x + BLOCK_SIZE, _width),
                     Math.Min(y + BLOCK_SIZE, _height),
                     radius);
              }
          }
      }
  }
  
  private unsafe void BlurBlock(byte* data, int startX, int startY, 
                              int endX, int endY, int radius)
  {
      // Реализация размытия для блока
      // ...
  }
}

// Пример NUMA-осознанного пула потоков
public class NumaAwareThreadPool
{
  private readonly ThreadPool[] _nodePools;
  
  public NumaAwareThreadPool()
  {
      // Определяем количество NUMA-узлов в системе
      int nodeCount = GetNumaNodeCount();
      _nodePools = new ThreadPool[nodeCount];
      
      for (int i = 0; i < nodeCount; i++)
      {
          // Создаём отдельный пул для каждого узла
          _nodePools[i] = new ThreadPool();
      }
  }
  
  public void QueueTask(Action task, int preferredNode)
  {
      // Размещаем задачу на предпочтительном NUMA-узле
      _nodePools[preferredNode].QueueUserWorkItem(_ => task());
  }
  
  private int GetNumaNodeCount()
  {
      // Получение количества NUMA-узлов через P/Invoke
      // ...
      return 2; // Упрощённая версия
  }
}

// Кэш-оптимизированная сортировка для массивов, которые не помещаются целиком в кэш
public void CacheAwareSort<T>(T[] array) where T : IComparable<T>
{
  // Сначала сортируем небольшие участки, помещающиеся в кэш
  const int BLOCK_SIZE = 512; // Подобрано экспериментально для L1 кэша
  
  for (int i = 0; i < array.Length; i += BLOCK_SIZE)
  {
      int blockEnd = Math.Min(i + BLOCK_SIZE, array.Length);
      Array.Sort(array, i, blockEnd - i);
  }
  
  // Затем объединяем отсортированные участки
  for (int size = BLOCK_SIZE; size < array.Length; size *= 2)
  {
      for (int i = 0; i < array.Length; i += 2 * size)
      {
          int mid = Math.Min(i + size, array.Length);
          int end = Math.Min(i + 2 * size, array.Length);
          
          if (mid < end)
              MergeInPlace(array, i, mid, end);
      }
  }
}

// Оптимизация разбора URL-параметров
public class CacheEfficientRouteValueProvider : IValueProvider
{
  private readonly PathString _path;
  private readonly RouteValueDictionary _values;
  
  // Используем разделяемый пул StringBuilders чтобы снизить давление на GC
  private static readonly ObjectPool<StringBuilder> _builderPool = 
      new DefaultObjectPool<StringBuilder>(new StringBuilderPooledObjectPolicy());
  
  public CacheEfficientRouteValueProvider(PathString path, RouteValueDictionary values)
  {
      _path = path;
      _values = values;
  }
  
  public bool ContainsPrefix(string prefix)
  {
      // Проверяем наличие префикса без создания новых строк
      foreach (var key in _values.Keys)
      {
          if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
              return true;
      }
      return false;
  }
  
  public ValueProviderResult GetValue(string key)
  {
      if (_values.TryGetValue(key, out var value))
      {
          // Используем пул для создания строкового представления
          var builder = _builderPool.Get();
          try
          {
              builder.Append(value);
              return new ValueProviderResult(builder.ToString());
          }
          finally
          {
              _builderPool.Return(builder);
          }
      }
      
      return ValueProviderResult.None;
  }
}

// Кэш-эффективная десериализация JSON
public class OptimizedJsonParser
{
  private static readonly JsonSerializerOptions _options = new()
  {
      PropertyNameCaseInsensitive = true,
      AllowTrailingCommas = true,
      ReadCommentHandling = JsonCommentHandling.Skip,
      // Используем структуры вместо классов где возможно
      // для улучшения локальности данных
      Converters = { new ValueTypeConverterFactory() }
  };
  
  // Используем Utf8JsonReader для потоковой обработки без создания промежуточных строк
  public IEnumerable<T> ParseJsonStream<T>(Stream jsonStream)
  {
      byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
      try
      {
          int bytesRead;
          while ((bytesRead = jsonStream.Read(buffer, 0, buffer.Length)) > 0)
          {
              ReadOnlySpan<byte> jsonSpan = new(buffer, 0, bytesRead);
              var reader = new Utf8JsonReader(jsonSpan);
              
              while (reader.Read())
              {
                  if (reader.TokenType == JsonTokenType.StartObject)
                  {
                      // Десериализуем объект без создания промежуточных строк
                      yield return JsonSerializer.Deserialize<T>(ref reader, _options);
                  }
              }
          }
      }
      finally
      {
          ArrayPool<byte>.Shared.Return(buffer);
      }
  }
}

// Кэш-эффективный обработчик телеметрии
public class TelemetryProcessor
{
  // Используем структуру массивов вместо массива структур
  private readonly float[] _cpuValues; 
  private readonly float[] _memoryValues;
  private readonly long[] _timestamps;
  private readonly int[] _serverIds;
  private int _currentIndex;
  
  public TelemetryProcessor(int capacity)
  {
      _cpuValues = new float[capacity];
      _memoryValues = new float[capacity];
      _timestamps = new long[capacity];
      _serverIds = new int[capacity];
  }
  
  public void AddDataPoint(int serverId, float cpu, float memory, long timestamp)
  {
      int index = Interlocked.Increment(ref _currentIndex) - 1;
      if (index < _cpuValues.Length)
      {
          _serverIds[index] = serverId;
          _cpuValues[index] = cpu;
          _memoryValues[index] = memory;
          _timestamps[index] = timestamp;
      }
  }
  
  // Вычисляем среднюю загрузку CPU отдельно для каждого сервера
  public IDictionary<int, float> CalculateAverageCpuPerServer()
  {
      var result = new Dictionary<int, float>();
      var counts = new Dictionary<int, int>();
      
      // Проходим по данным последовательно для лучшей локальности
      for (int i = 0; i < Math.Min(_currentIndex, _cpuValues.Length); i++)
      {
          int serverId = _serverIds[i];
          if (!result.ContainsKey(serverId))
          {
              result[serverId] = 0;
              counts[serverId] = 0;
          }
          
          result[serverId] += _cpuValues[i];
          counts[serverId]++;
      }
      
      // Вычисляем средние значения
      foreach (var serverId in result.Keys.ToList())
      {
          result[serverId] /= counts[serverId];
      }
      
      return result;
  }
}

// Кэш-оптимизированное скользящее окно для финансовых данных
public class CacheOptimizedRingBuffer<T>
{
  private readonly T[] _buffer;
  private int _head;
  private readonly int _capacity;
  
  public CacheOptimizedRingBuffer(int capacity)
  {
      _capacity = capacity;
      // Выделяем буфер на +1 больше для избежания граничных проверок
      _buffer = new T[capacity + 1];
      _head = 0;
  }
  
  public void Add(T item)
  {
      _buffer[_head] = item;
      _head = (_head + 1) % _capacity;
  }
  
  // Важно: возвращаем Span<T> вместо IEnumerable<T>
  // для улучшения локальности и избежания аллокаций
  public ReadOnlySpan<T> GetWindow()
  {
      if (_head < _capacity)
      {
          // Данные непрерывны в памяти
          return new ReadOnlySpan<T>(_buffer, 0, _head);
      }
      else
      {
          // Данные "заворачиваются" - копируем во временный буфер
          // для обеспечения непрерывности в памяти
          T[] temp = ArrayPool<T>.Shared.Rent(_capacity);
          try
          {
              int tailSize = _capacity - _head;
              Array.Copy(_buffer, _head, temp, 0, tailSize);
              Array.Copy(_buffer, 0, temp, tailSize, _head);
              return new ReadOnlySpan<T>(temp, 0, _capacity);
          }
          finally
          {
              ArrayPool<T>.Shared.Return(temp);
          }
      }
  }
}

public class DistributedStatsAggregator
{
    private readonly Dictionary<string, AggregationData> _localCache 
        = new Dictionary<string, AggregationData>();
    private readonly IDistributedCache _remoteCache;
    
    // Структура оптимизирована для компактности и эффективного размещения в кэше
    private struct AggregationData
    {
        public long Count;
        public double Sum;
        public double SumOfSquares;
        public DateTime LastUpdated;
        
        // Избегаем дополнительных полей, чтобы уменьшить размер структуры
    }
    
    public async Task UpdateStatistic(string key, double value)
    {
        // Сначала работаем с локальным кэшем для максимальной скорости
        if (!_localCache.TryGetValue(key, out var data))
        {
            // При промахе в локальном кэше проверяем распределённый
            string cachedValue = await _remoteCache.GetStringAsync(key);
            if (!string.IsNullOrEmpty(cachedValue))
                data = JsonSerializer.Deserialize<AggregationData>(cachedValue);
        }
        
        // Обновляем статистику
        data.Count++;
        data.Sum += value;
        data.SumOfSquares += value * value;
        data.LastUpdated = DateTime.UtcNow;
        
        // Сохраняем в локальный кэш
        _localCache[key] = data;
        
        // В фоновом режиме синхронизируем с распределённым кэшем,
        // чтобы не блокировать основной поток
        _ = Task.Run(async () =>
        {
            await _remoteCache.SetStringAsync(
                key,
                JsonSerializer.Serialize(data),
                new DistributedCacheEntryOptions
                {
                    SlidingExpiration = TimeSpan.FromMinutes(30)
                });
        });
    }
}

public class HotKeyCacheLocalizer
{
    private readonly int _nodeCount;
    private readonly int _currentNodeId;
    
    // Определяем, какой узел должен обрабатывать конкретный ключ
    public int GetResponsibleNodeForKey(string key)
    {
        // Простой алгоритм консистентного хэширования
        return Math.Abs(key.GetHashCode()) % _nodeCount;
    }
    
    public bool ShouldProcessLocally(string key)
    {
        return GetResponsibleNodeForKey(key) == _currentNodeId;
    }
    
    // При обработке запроса
    public async Task<Result> ProcessRequest(string key, RequestData requestData)
    {
        // Если этот ключ не должен обрабатываться здесь,
        // перенаправляем запрос на соответствующий узел
        if (!ShouldProcessLocally(key))
        {
            int targetNode = GetResponsibleNodeForKey(key);
            return await ForwardRequestToNode(targetNode, key, requestData);
        }
        
        // Иначе обрабатываем локально, что даёт выигрыш от кэша
        return ProcessLocally(key, requestData);
    }
}

public class CacheFriendlyGraph
{
    // Вершины графа просто индексируются числами от 0 до VertexCount-1
    
    // Массив смещений: OffsetArray[i] указывает, с какого индекса
    // в EdgeArray начинаются рёбра для вершины i
    private readonly int[] _offsetArray;
    
    // Массив рёбер: хранит список смежных вершин для всех вершин
    // последовательно, без разрывов
    private readonly int[] _edgeArray;
    
    public CacheFriendlyGraph(int vertexCount, List<(int From, int To)> edges)
    {
        _offsetArray = new int[vertexCount + 1];
        
        // Сначала подсчитываем, сколько рёбер у каждой вершины
        foreach (var (from, _) in edges)
        {
            _offsetArray[from + 1]++;
        }
        
        // Преобразуем количества в смещения
        for (int i = 0; i < vertexCount; i++)
        {
            _offsetArray[i + 1] += _offsetArray[i];
        }
        
        // Заполняем массив рёбер
        _edgeArray = new int[edges.Count];
        int[] currentOffset = new int[vertexCount];
        
        foreach (var (from, to) in edges)
        {
            int index = _offsetArray[from] + currentOffset[from]++;
            _edgeArray[index] = to;
        }
    }
    
    // Получение всех соседей вершины - очень эффективная операция
    // с точки зрения кэша, так как все соседи хранятся последовательно
    public ReadOnlySpan<int> GetNeighbors(int vertex)
    {
        int start = _offsetArray[vertex];
        int end = _offsetArray[vertex + 1];
        return new ReadOnlySpan<int>(_edgeArray, start, end - start);
    }
    
    // Пример: обход графа в ширину с учётом кэша
    public void BreadthFirstTraversal(int startVertex, Action<int> visitAction)
    {
        bool[] visited = new bool[_offsetArray.Length - 1];
        Queue<int> queue = new Queue<int>();
        
        visited[startVertex] = true;
        queue.Enqueue(startVertex);
        
        while (queue.Count > 0)
        {
            int current = queue.Dequeue();
            visitAction(current);
            
            // Получаем всех соседей за одно обращение к памяти
            ReadOnlySpan<int> neighbors = GetNeighbors(current);
            
            // Обрабатываем соседей пакетно для лучшей локальности
            foreach (int neighbor in neighbors)
            {
                if (!visited[neighbor])
                {
                    visited[neighbor] = true;
                    queue.Enqueue(neighbor);
                }
            }
        }
    }
}

public class CacheAwareBTree<TKey, TValue> where TKey : IComparable<TKey>
{
    // Оптимальная степень B-дерева зависит от размера кэш-линии
    private readonly int _degree;
    
    private class Node
    {
        // Ключи и значения хранятся в отдельных массивах для лучшей локальности
        // при бинарном поиске по ключам
        public TKey[] Keys;
        public TValue[] Values;
        public Node[] Children;
        public int KeyCount;
        public bool IsLeaf;
        
        public Node(int degree, bool isLeaf)
        {
            IsLeaf = isLeaf;
            Keys = new TKey[2 * degree - 1];
            Values = new TValue[2 * degree - 1];
            Children = isLeaf ? null : new Node[2 * degree];
            KeyCount = 0;
        }
    }
    
    // Определяем оптимальную степень дерева на основе размера кэш-линии
    private static int CalculateOptimalDegree<TK, TV>()
    {
        // Примерный размер узла в байтах
        int keySize = Marshal.SizeOf<TK>();
        int valueSize = Marshal.SizeOf<TV>();
        int pointerSize = IntPtr.Size;
        
        // Целевой размер - половина типичной кэш-линии (32 байта)
        const int targetSize = 32;
        
        // Решаем уравнение: (2*d-1)*(keySize + valueSize) + 2*d*pointerSize + overhead <= targetSize
        // Упрощаем до: 2*d*(keySize + valueSize + pointerSize) - (keySize + valueSize) <= targetSize
        
        int elementSize = keySize + valueSize + pointerSize;
        int degree = Math.Max(2, (targetSize + keySize + valueSize) / (2 * elementSize));
        
        return degree;
    }
    
    // Конструктор автоматически определяет оптимальную степень
    public CacheAwareBTree()
    {
        _degree = CalculateOptimalDegree<TKey, TValue>();
    }
    
    // Дальше идёт стандартная реализация операций B-дерева,
    // но с учётом оптимальной степени для кэша
    // ...
}

public class SpatialGrid
{
    private readonly Dictionary<(int X, int Y, int Z), List<EntityRef>> _grid 
        = new Dictionary<(int X, int Y, int Z), List<EntityRef>>();
    private readonly float _cellSize;
    
    // Более кэш-эффективная структура для хранения ссылок на сущности
    private readonly struct EntityRef
    {
        public readonly int EntityId;
        // Храним позицию внутри ссылки, чтобы уменьшить 
        // количество прыжков по памяти при проверках
        public readonly Vector3 Position;
        
        public EntityRef(int entityId, Vector3 position)
        {
            EntityId = entityId;
            Position = position;
        }
    }
    
    public void UpdateEntityPosition(int entityId, Vector3 oldPosition, Vector3 newPosition)
    {
        // Получаем координаты ячеек
        var oldCell = GetCellCoordinates(oldPosition);
        var newCell = GetCellCoordinates(newPosition);
        
        // Если ячейка изменилась, перемещаем сущность
        if (oldCell != newCell)
        {
            RemoveFromCell(entityId, oldCell);
            AddToCell(entityId, newCell, newPosition);
        }
    }
    
    // Получаем все сущности в заданном радиусе от точки
    public List<int> GetEntitiesInRadius(Vector3 position, float radius)
    {
        List<int> result = new List<int>();
        
        // Определяем границы поиска в ячейках
        float radiusCells = radius / _cellSize;
        int radiusCellsInt = (int)Math.Ceiling(radiusCells);
        
        // Координаты центральной ячейки
        var centerCell = GetCellCoordinates(position);
        
        // Для улучшения локальности данных в кэше,
        // обходим ячейки по слоям от центра к периферии
        for (int layer = 0; layer <= radiusCellsInt; layer++)
        {
            // Для каждого слоя обходим только его границу
            for (int x = -layer; x <= layer; x++)
            {
                for (int y = -layer; y <= layer; y++)
                {
                    for (int z = -layer; z <= layer; z++)
                    {
                        // Пропускаем ячейки, не находящиеся на границе слоя
                        if (Math.Max(Math.Max(Math.Abs(x), Math.Abs(y)), Math.Abs(z)) < layer)
                            continue;
                        
                        var cell = (centerCell.X + x, centerCell.Y + y, centerCell.Z + z);
                        if (_grid.TryGetValue(cell, out var entities))
                        {
                            foreach (var entityRef in entities)
                            {
                                // Проверяем точное расстояние до сущности
                                if (Vector3.Distance(position, entityRef.Position) <= radius)
                                {
                                    result.Add(entityRef.EntityId);
                                }
                            }
                        }
                    }
                }
            }
        }
        
        return result;
    }
    
    private (int X, int Y, int Z) GetCellCoordinates(Vector3 position)
    {
        return ((int)(position.X / _cellSize),
                (int)(position.Y / _cellSize),
                (int)(position.Z / _cellSize));
    }
    
    private void AddToCell(int entityId, (int X, int Y, int Z) cell, Vector3 position)
    {
        if (!_grid.TryGetValue(cell, out var list))
        {
            list = new List<EntityRef>();
            _grid[cell] = list;
        }
        
        list.Add(new EntityRef(entityId, position));
    }
    
    private void RemoveFromCell(int entityId, (int X, int Y, int Z) cell)
    {
        if (_grid.TryGetValue(cell, out var list))
        {
            list.RemoveAll(e => e.EntityId == entityId);
            if (list.Count == 0)
                _grid.Remove(cell);
        }
    }
}