Максимальная производительность C#: Векторизация (SIMD)

using System.Numerics;
 
// Складываем массивы чисел векторно
public void AddArrays(float[] a, float[] b, float[] result)
{
    int vectorSize = Vector<float>.Count; // Количество элементов в векторе
    int i = 0;
    
    // Векторизованная часть
    for (; i <= a.Length - vectorSize; i += vectorSize)
    {
        var va = new Vector<float>(a, i);
        var vb = new Vector<float>(b, i);
        (va + vb).CopyTo(result, i);
    }
    
    // Остаток обрабатываем скалярно
    for (; i < a.Length; i++)
    {
        result[i] = a[i] + b[i];
    }
}

using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
 
public void MultiplyArrays(float[] a, float[] b, float[] result)
{
    if (Avx.IsSupported) // Проверяем поддержку AVX
    {
        for (int i = 0; i < a.Length; i += 8)
        {
            var va = Vector256.Create(a[i], a[i+1], a[i+2], a[i+3], 
                                      a[i+4], a[i+5], a[i+6], a[i+7]);
            var vb = Vector256.Create(b[i], b[i+1], b[i+2], b[i+3], 
                                      b[i+4], b[i+5], b[i+6], b[i+7]);
            
            var result256 = Avx.Multiply(va, vb);
            
            Avx.Store(result.AsSpan(i), result256);
        }
    }
    else // Запасной план для старых процессоров
    {
        for (int i = 0; i < a.Length; i++)
            result[i] = a[i] * b[i];
    }
}

void AddArrays(float[] a, float[] b, float[] result)
{
  for (int i = 0; i < a.Length; i++)
      result[i] = a[i] + b[i];
}

for (int i = 1; i < data.Length; i++)
{
  data[i] += data[i - 1]; // Зависимость между итерациями
}

// Оптимизированная версия с разворачиванием цикла
int vectorSize = Vector<float>.Count;
int i = 0;
for (; i <= a.Length - vectorSize * 4; i += vectorSize * 4)
{
  var va1 = new Vector<float>(a, i);
  var va2 = new Vector<float>(a, i + vectorSize);
  var va3 = new Vector<float>(a, i + vectorSize * 2);
  var va4 = new Vector<float>(a, i + vectorSize * 3);
  
  // Операции над четырьмя векторами...
  
  // Сохраняем результаты
}

// Скалярная версия
float DotProductScalar(float[] a, float[] b)
{
  float sum = 0;
  for (int i = 0; i < a.Length; i++)
      sum += a[i] * b[i];
  return sum;
}
 
// Векторизованная версия
float DotProductVector(float[] a, float[] b)
{
  Vector<float> sumVector = Vector<float>.Zero;
  int vectorSize = Vector<float>.Count;
  int i = 0;
  
  for (; i <= a.Length - vectorSize; i += vectorSize)
  {
      var va = new Vector<float>(a, i);
      var vb = new Vector<float>(b, i);
      sumVector += va * vb;
  }
  
  // Суммируем элементы вектора
  float sum = 0;
  for (int j = 0; j < vectorSize; j++)
      sum += sumVector[j];
  
  // Обрабатываем остаток
  for (; i < a.Length; i++)
      sum += a[i] * b[i];
  
  return sum;
}

// Применение размытия по Гауссу с использованием SIMD
void ApplyGaussianBlur(Span<byte> source, Span<byte> destination, int width, int height, int stride)
{
  // Для каждого пикселя изображения (кроме границ)
  for (int y = 2; y < height - 2; y++)
  {
      int rowOffset = y * stride;
      
      // Векторизуем обработку каждой строки
      for (int x = 2; x <= width - 2 - Vector<byte>.Count; x += Vector<byte>.Count)
      {
          int offset = rowOffset + x * 4; // 4 байта на пиксель (RGBA)
          
          // Загружаем 5x5 пикселей вокруг текущей позиции
          // и применяем ядро свертки через векторные операции
          // ...
      }
  }
}

// Правильный подход: распараллеливаем крупные блоки данных,
// внутри каждого блока применяем векторизацию
Parallel.For(0, blockCount, blockIndex =>
{
    int start = blockIndex * blockSize;
    int end = Math.Min(start + blockSize, data.Length);
    
    // Векторизованный код внутри каждого потока
    Vector<float> accumulator = Vector<float>.Zero;
    for (int i = start; i < end - Vector<float>.Count; i += Vector<float>.Count)
    {
        var v = new Vector<float>(data, i);
        accumulator += v * v;
    }
    
    // Обработка результатов...
});

// Антипаттерн: потоки конкурируют за одни и те же кэш-линии
Vector<float>[] results = new Vector<float>[Environment.ProcessorCount];
Parallel.For(0, Environment.ProcessorCount, threadIndex =>
{
    // Каждый поток пишет в свой элемент массива,
    // но эти элементы могут находиться в одной кэш-линии
    results[threadIndex] = ComputeVector();
});
 
// Лучший подход: размещаем результаты с учетом кэш-линий
const int CACHE_LINE_SIZE = 64; // байт
const int PADDING = CACHE_LINE_SIZE / sizeof(float);
float[] paddedResults = new float[Environment.ProcessorCount * PADDING];
Parallel.For(0, Environment.ProcessorCount, threadIndex =>
{
    // Теперь каждый поток работает с отдельной кэш-линией
    int offset = threadIndex * PADDING;
    Vector<float> result = ComputeVector();
    for (int i = 0; i < Vector<float>.Count; i++)
        paddedResults[offset + i] = result[i];
});

using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
 
// Вычисление хеша данных с использованием SHA инструкций
public unsafe byte[] ComputeSha256(byte[] data)
{
    // Проверяем поддержку SHA инструкций
    if (Sha.IsSupported)
    {
        fixed (byte* pData = data)
        {
            var state = new Vector128<uint>[8]; // Хранит состояние хеша
            
            // Инициализация начального состояния SHA-256
            state[0] = Vector128.Create(0x6A09E667u);
            state[1] = Vector128.Create(0xBB67AE85u);
            // и т.д. для остальных констант
            
            // Используем аппаратное ускорение SHA
            int offset = 0;
            while (offset <= data.Length - 64) // Обрабатываем блоки по 64 байта
            {
                var block = (byte*)(pData + offset);
                
                // Одна инструкция вместо десятков вычислений
                Sha256.HashUpdate(ref state[0], ref state[1], ref state[2], ref state[3],
                               ref state[4], ref state[5], ref state[6], ref state[7], block);
                
                offset += 64;
            }
            
            // Обработка результата и оставшихся данных
            // ...
            
            // Возвращаем 32-байтовый хеш
            byte[] result = new byte[32];
            // Копируем результат из state в result
            return result;
        }
    }
    else
    {
        // Запасной вариант для процессоров без поддержки SHA инструкций
        using var hasher = System.Security.Cryptography.SHA256.Create();
        return hasher.ComputeHash(data);
    }
}

// Пример адаптивной векторизации с учетом энергопотребления
public void ProcessDataAdaptive(float[] data, bool batteryLow)
{
    if (batteryLow && IsRunningOnMobile())
    {
        // В режиме экономии энергии используем более экономичный алгоритм
        // с меньшей степенью векторизации
        for (int i = 0; i < data.Length; i++)
            data[i] = ProcessItem(data[i]);
    }
    else
    {
        // При нормальном энергопотреблении используем полную векторизацию
        int vectorSize = Vector<float>.Count;
        for (int i = 0; i <= data.Length - vectorSize; i += vectorSize)
        {
            var v = new Vector<float>(data, i);
            (ProcessVector(v)).CopyTo(data, i);
        }
        
        // Обработка оставшихся элементов
        // ...
    }
}

// Векторизованный расчет цен опционов по модели Блэка-Шоулза
public Vector<double> BlackScholesVector(
    Vector<double> spotPrices,
    Vector<double> strikePrices,
    Vector<double> timeToMaturity,
    Vector<double> riskFreeRates,
    Vector<double> volatilities,
    bool isCall)
{
    // Векторное вычисление параметров модели
    var sqrtTime = Vector.Sqrt(timeToMaturity);
    var d1 = Vector.Divide(
        Vector.Add(
            Vector.Log(Vector.Divide(spotPrices, strikePrices)),
            Vector.Multiply(
                Vector.Add(riskFreeRates, 
                    Vector.Multiply(Vector.Multiply(volatilities, volatilities), 
                        new Vector<double>(0.5))),
                timeToMaturity)),
        Vector.Multiply(volatilities, sqrtTime));
        
    var d2 = Vector.Subtract(d1, Vector.Multiply(volatilities, sqrtTime));
    
    // Кумулятивная функция нормального распределения (приближение)
    var nd1 = CumulativeNormalVector(d1);
    var nd2 = CumulativeNormalVector(d2);
    
    // Расчет стоимости опциона
    if (isCall)
    {
        return Vector.Subtract(
            Vector.Multiply(spotPrices, nd1),
            Vector.Multiply(
                Vector.Multiply(
                    strikePrices,
                    Vector.Exp(Vector.Negate(Vector.Multiply(riskFreeRates, timeToMaturity)))),
                nd2));
    }
    else
    {
        // Для PUT-опционов логика немного другая
        // ...
    }
}

// Стандартный LINQ-запрос
var result = numbers
    .Where(x => x > 0)
    .Select(x => (float)Math.Sqrt(x))
    .Sum();
 
// Векторизованная версия того же запроса
Vector<float> threshold = Vector<float>.Zero;
Vector<float> sumVector = Vector<float>.Zero;
 
for (int i = 0; i <= numbers.Length - Vector<float>.Count; i += Vector<float>.Count)
{
    var v = new Vector<float>(numbers, i);
    
    // Векторный эквивалент Where: создаем маску для элементов > 0
    var mask = Vector.GreaterThan(v, threshold);
    
    // Векторный эквивалент Select: извлекаем квадратный корень
    // (только для положительных элементов, согласно маске)
    var sqrtV = Vector.ConditionalSelect(
        mask,
        Vector.Sqrt(v),
        Vector<float>.Zero);
    
    // Векторный эквивалент Sum: накапливаем результат
    sumVector = Vector.Add(sumVector, sqrtV);
}
 
// Горизонтальное суммирование вектора для получения скалярного результата
float sum = 0;
for (int i = 0; i < Vector<float>.Count; i++)
    sum += sumVector[i];
 
// Обработка остатка...

using Microsoft.Diagnostics.Tracing.Parsers.Clr;
using Microsoft.Diagnostics.Tracing.Session;
 
// Создаем сессию ETW для сбора данных о векторизации
using (var session = new TraceEventSession("VectorizationAnalysis"))
{
  // Включаем сбор счетчиков JIT-компиляции
  session.EnableProvider(ClrTraceEventParser.ProviderGuid,
      TraceEventLevel.Verbose,
      (ulong)ClrTraceEventParser.Keywords.JitTracing);
      
  // Запускаем нашу векторизованную функцию
  RunVectorizedAlgorithm();
  
  // Анализируем собранные данные
  // ...
}

public class SparseMatrixCsr
{
  private readonly float[] _values; // Ненулевые значения
  private readonly int[] _columnIndices; // Индексы столбцов для ненулевых элементов
  private readonly int[] _rowPointers; // Указатели начала каждой строки в массивах values и columnIndices
  
  public void MultiplyByVector(ReadOnlySpan<float> vector, Span<float> result)
  {
      // Для каждой строки матрицы
      for (int row = 0; row < _rowPointers.Length - 1; row++)
      {
          // Начальный и конечный индексы элементов строки
          int start = _rowPointers[row];
          int end = _rowPointers[row + 1];
          
          // Накопители для сумм
          Vector<float> sum = Vector<float>.Zero;
          int i = start;
          
          // Векторизация внутри каждой строки, если есть достаточно элементов
          for (; i <= end - Vector<float>.Count; i += Vector<float>.Count)
          {
              // Загружаем несколько последовательных значений
              var values = new Vector<float>(_values, i);
              
              // Здесь непрерывная последовательность прерывается:
              // нам нужны разрозненные элементы из вектора, соответствующие columnIndices
              // Это "узкое место" векторизации для разреженных данных
              
              // Один из подходов - собрать нужные элементы в временный массив
              float[] temp = new float[Vector<float>.Count];
              for (int j = 0; j < Vector<float>.Count; j++)
                  temp[j] = vector[_columnIndices[i + j]];
              
              var vectorElements = new Vector<float>(temp);
              sum += values * vectorElements;
          }
          
          // Обработка оставшихся элементов и финализация
          // ...
      }
  }
}

using System.Runtime.Intrinsics.X86;
 
// С использованием AVX-512 gather
if (Avx512F.IsSupported)
{
  var indices = Vector512.Create(
      _columnIndices[i],
      _columnIndices[i+1],
      // ... остальные индексы
  );
  
  // Собираем элементы из vector по указанным индексам
  var gathered = Avx512F.GatherVector256(
      vector.AsSpan().ToArray(),
      indices,
      scale: 4); // sizeof(float)
      
  // Умножаем на значения и суммируем
  sum += gathered * values;
}

using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
 
public void ProcessImageArm(Span<byte> pixels)
{
  if (AdvSimd.IsSupported) // ARM NEON
  {
      for (int i = 0; i < pixels.Length; i += 16)
      {
          var pixelVector = AdvSimd.LoadVector128(pixels.Slice(i).ToArray());
          
          // Увеличиваем яркость
          var result = AdvSimd.Add(pixelVector, Vector128.Create((byte)30));
          
          // Применяем насыщение, чтобы избежать переполнения байта
          result = AdvSimd.Min(result, Vector128.Create((byte)255));
          
          AdvSimd.Store(pixels.Slice(i).ToArray(), result);
      }
  }
  else
  {
      // Запасная реализация для устройств без поддержки NEON
      // ...
  }
}

public void ProcessData(float[] data)
{
  if (Avx2.IsSupported)
      ProcessDataAvx2(data);
  else if (Sse2.IsSupported)
      ProcessDataSse2(data);
  else if (AdvSimd.IsSupported)
      ProcessDataNeon(data);
  else
      ProcessDataFallback(data);
}

public static int FindQuote(ReadOnlySpan<byte> json, int startIndex)
{
  Vector<byte> quoteVector = new Vector<byte>((byte)'"');
  int vectorSize = Vector<byte>.Count;
  
  for (int i = startIndex; i <= json.Length - vectorSize; i += vectorSize)
  {
      var chunk = new Vector<byte>(json.Slice(i, vectorSize));
      var matches = Vector.Equals(chunk, quoteVector);
      
      if (matches != Vector<byte>.Zero)
      {
          for (int j = 0; j < vectorSize; j++)
          {
              if (matches[j] != 0)
                  return i + j;
          }
      }
  }
  
  // Проверяем остаток
  for (int i = json.Length - (json.Length % vectorSize); i < json.Length; i++)
  {
      if (json[i] == (byte)'"')
          return i;
  }
  
  return -1;
}

// Скалярная версия
float[] FeedForward(float[] inputs, float[,] weights, float[] biases)
{
    float[] outputs = new float[biases.Length];
    for (int i = 0; i < outputs.Length; i++)
    {
        outputs[i] = biases[i];
        for (int j = 0; j < inputs.Length; j++)
            outputs[i] += inputs[j] * weights[i, j];
        
        // Активация ReLU
        outputs[i] = Math.Max(0, outputs[i]);
    }
    return outputs;
}

float[] FeedForwardVectorized(float[] inputs, float[,] weights, float[] biases)
{
    float[] outputs = new float[biases.Length];
    int vectorSize = Vector<float>.Count;
    
    // Для каждого нейрона выходного слоя
    for (int i = 0; i < outputs.Length; i++)
    {
        Vector<float> sum = new Vector<float>(biases[i]);
        int j = 0;
        
        // Векторизация умножения входов на веса
        for (; j <= inputs.Length - vectorSize; j += vectorSize)
        {
            var inputVector = new Vector<float>(inputs, j);
            var weightVector = new Vector<float>(GetWeightRow(weights, i, j, vectorSize));
            sum += inputVector * weightVector;
        }
        
        // Суммируем элементы результирующего вектора
        float scalarSum = 0;
        for (int k = 0; k < vectorSize; k++)
            scalarSum += sum[k];
        
        // Обрабатываем оставшиеся элементы
        for (; j < inputs.Length; j++)
            scalarSum += inputs[j] * weights[i, j];
        
        // Активация ReLU
        outputs[i] = Math.Max(0, scalarSum);
    }
    return outputs;
    
    // Вспомогательный метод для получения строки весов
    float[] GetWeightRow(float[,] weights, int row, int startCol, int count)
    {
        float[] rowSlice = new float[count];
        for (int k = 0; k < count; k++)
            rowSlice[k] = weights[row, startCol + k];
        return rowSlice;
    }
}

// Оптимизированная структура хранения весов для векторизации
public class OptimizedNeuralNetwork
{
    private float[][] _weightRows; // Веса хранятся построчно для лучшей локальности
    private float[] _biases;
    private int _inputSize;
    private int _outputSize;
    
    // Метод прямого распространения с векторизацией и локальностью данных
    public float[] FeedForward(float[] inputs)
    {
        float[] outputs = new float[_outputSize];
        int vectorSize = Vector<float>.Count;
        
        Parallel.For(0, _outputSize, i =>
        {
            var rowWeights = _weightRows[i];
            Vector<float> sum = new Vector<float>(_biases[i]);
            int j = 0;
            
            for (; j <= _inputSize - vectorSize; j += vectorSize)
            {
                var inputVector = new Vector<float>(inputs, j);
                var weightVector = new Vector<float>(rowWeights, j);
                sum += inputVector * weightVector;
            }
            
            // Горизонтальное суммирование с использованием SIMD
            outputs[i] = HorizontalSum(sum);
            
            // Дообработка остатка и применение активации
            for (; j < _inputSize; j++)
                outputs[i] += inputs[j] * rowWeights[j];
            
            // ReLU активация
            outputs[i] = MathF.Max(0, outputs[i]);
        });
        
        return outputs;
    }
    
    // Эффективное горизонтальное суммирование вектора
    private float HorizontalSum(Vector<float> vector)
    {
        float sum = 0;
        for (int i = 0; i < Vector<float>.Count; i++)
            sum += vector[i];
        return sum;
    }
}

public class RealTimeStreamProcessor
{
    private readonly float[] _buffer;
    private readonly int _windowSize;
    private int _currentPosition;
    
    // Метод добавления нового значения с векторизованной обработкой
    public float ProcessNewValue(float newValue)
    {
        // Добавляем новое значение в кольцевой буфер
        _buffer[_currentPosition] = newValue;
        _currentPosition = (_currentPosition + 1) % _buffer.Length;
        
        // Вычисляем скользящее среднее с векторизацией
        return ComputeWindowStatistics();
    }
    
    private float ComputeWindowStatistics()
    {
        Vector<float> sumVector = Vector<float>.Zero;
        int vectorSize = Vector<float>.Count;
        int processed = 0;
        
        // Если у нас есть достаточно элементов для векторной обработки
        while (processed + vectorSize <= _windowSize)
        {
            // Получаем подпоследовательность из кольцевого буфера
            float[] temp = GetWindowSlice(processed, vectorSize);
            var vector = new Vector<float>(temp);
            
            // Выполняем векторную операцию (например, суммирование)
            sumVector += vector;
            processed += vectorSize;
        }
        
        // Суммируем элементы вектора
        float sum = 0;
        for (int i = 0; i < vectorSize; i++)
            sum += sumVector[i];
        
        // Обрабатываем оставшиеся элементы
        for (int i = processed; i < _windowSize; i++)
        {
            int index = (_currentPosition - _windowSize + i + _buffer.Length) % _buffer.Length;
            sum += _buffer[index];
        }
        
        return sum / _windowSize;
    }
    
    private float[] GetWindowSlice(int offset, int count)
    {
        float[] result = new float[count];
        for (int i = 0; i < count; i++)
        {
            int bufferIndex = (_currentPosition - _windowSize + offset + i + _buffer.Length) % _buffer.Length;
            result[i] = _buffer[bufferIndex];
        }
        return result;
    }
}

// Векторизованный поиск подстроки (упрощенная версия)
public static int VectorizedIndexOf(ReadOnlySpan<char> text, ReadOnlySpan<char> pattern)
{
    if (pattern.IsEmpty) return 0;
    if (pattern.Length > text.Length) return -1;
    
    // Если образец достаточно короткий, используем первый символ
    // как маркер для быстрого пропуска заведомо несовпадающих позиций
    char firstChar = pattern[0];
    Vector<short> firstCharVector = new Vector<short>(firstChar);
    
    int vectorSize = Vector<short>.Count;
    int maxPosition = text.Length - pattern.Length;
    
    for (int i = 0; i <= maxPosition; i += vectorSize)
    {
        int charsLeft = Math.Min(vectorSize, maxPosition + 1 - i);
        
        // Создаем вектор из текущего фрагмента текста
        short[] textChars = new short[vectorSize];
        for (int j = 0; j < charsLeft; j++)
            textChars[j] = (short)text[i + j];
        
        var textVector = new Vector<short>(textChars);
        
        // Проверяем, где первый символ шаблона совпадает с символами в тексте
        var matches = Vector.Equals(textVector, firstCharVector);
        
        if (matches != Vector<short>.Zero)
        {
            // Если есть совпадения, проверяем их последовательно
            for (int j = 0; j < charsLeft; j++)
            {
                if (matches[j] != 0 && MatchesAt(text, pattern, i + j))
                    return i + j;
            }
        }
    }
    
    return -1;
}
 
private static bool MatchesAt(ReadOnlySpan<char> text, ReadOnlySpan<char> pattern, int position)
{
    if (text.Length - position < pattern.Length)
        return false;
        
    for (int i = 1; i < pattern.Length; i++) // Начинаем с 1, т.к. первый символ уже проверен
        if (text[position + i] != pattern[i])
            return false;
            
    return true;
}

// Векторизованное физическое моделирование частиц
public void UpdateParticles(Span<Vector3> positions, Span<Vector3> velocities, Span<Vector3> forces, float deltaTime)
{
    int vectorSize = Vector<float>.Count;
    int particleCount = positions.Length;
    
    // Обрабатываем X, Y, Z компоненты отдельно для лучшей векторизации
    for (int i = 0; i <= particleCount - vectorSize; i += vectorSize)
    {
        // Извлекаем X-компоненты из нескольких частиц
        Vector<float> posX = ExtractComponent(positions.Slice(i, vectorSize), 0);
        Vector<float> velX = ExtractComponent(velocities.Slice(i, vectorSize), 0);
        Vector<float> forceX = ExtractComponent(forces.Slice(i, vectorSize), 0);
        
        // Обновляем скорость и позицию (по X)
        velX += forceX * new Vector<float>(deltaTime);
        posX += velX * new Vector<float>(deltaTime);
        
        // Аналогично для Y и Z компонент
        // ...
        
        // Записываем результаты обратно
        StoreComponent(positions.Slice(i, vectorSize), posX, 0);
        StoreComponent(velocities.Slice(i, vectorSize), velX, 0);
    }
    
    // Обработка оставшихся частиц
}

// Фабрика специализированных реализаций в зависимости от платформы
public static IImageProcessor CreateOptimalProcessor()
{
    if (OperatingSystem.IsAndroid() || OperatingSystem.IsIOS())
    {
        if (AdvSimd.IsSupported)
            return new ArmNeonImageProcessor();
    }
    else
    {
        if (Avx2.IsSupported)
            return new Avx2ImageProcessor();
        else if (Sse2.IsSupported)
            return new Sse2ImageProcessor();
    }
    
    // Резервная реализация для любой платформы
    return new ScalarImageProcessor();
}

public class ArmNeonImageProcessor : IImageProcessor
{
    public unsafe void ApplyFilter(byte[] image, int width, int height)
    {
        if (!AdvSimd.IsSupported)
            throw new NotSupportedException("NEON not supported");
        
        fixed (byte* pImage = image)
        {
            for (int i = 0; i < image.Length; i += 16)
            {
                // Загружаем 16 байт (4 пикселя RGBA) в 128-битный вектор
                Vector128<byte> pixels = AdvSimd.LoadVector128(pImage + i);
                
                // Например, уменьшаем синий канал
                Vector128<byte> mask = Vector128.Create(
                    0xFF, 0xFF, 0x80, 0xFF,
                    0xFF, 0xFF, 0x80, 0xFF,
                    0xFF, 0xFF, 0x80, 0xFF,
                    0xFF, 0xFF, 0x80, 0xFF);
                    
                Vector128<byte> result = AdvSimd.And(pixels, mask);
                
                // Сохраняем результат
                AdvSimd.Store(pImage + i, result);
            }
        }
    }
}

public static int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
{
    // Для очень коротких строк используем обычный алгоритм
    if (value.Length <= 2 || source.Length < 32)
        return source.IndexOf(value);
    
    // Для длинных строк применяем векторизованное сравнение
    return SimdIndexOf(source, value);
}
 
private static int SimdIndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
{
    // Создаем "отпечаток" первых нескольких символов паттерна
    Vector<short> firstChars = CreatePatternVector(value);
    char lastChar = value[value.Length - 1];
    
    int i = 0;
    while (i <= source.Length - value.Length)
    {
        // Проверяем, совпадает ли последний символ паттерна
        if (source[i + value.Length - 1] == lastChar)
        {
            // Если совпадает, проверяем первые символы векторно
            bool potentialMatch = CompareFirstCharsVector(
                source.Slice(i, Vector<short>.Count),
                firstChars);
                
            if (potentialMatch)
            {
                // Проверяем полное совпадение
                bool fullMatch = true;
                for (int j = Vector<short>.Count; j < value.Length - 1; j++)
                {
                    if (source[i + j] != value[j])
                    {
                        fullMatch = false;
                        break;
                    }
                }
                
                if (fullMatch)
                    return i;
            }
        }
        
        // Ищем следующее потенциальное совпадение
        i += GetSkipDistance(source, value, i);
    }
    
    return -1;
}

public static bool ContainsOnlyDigits(ReadOnlySpan<char> text)
{
    Vector<short> zero = new Vector<short>('0');
    Vector<short> nine = new Vector<short>('9');
    
    int vectorSize = Vector<short>.Count;
    int i = 0;
    
    // Векторизованная проверка групп символов
    for (; i <= text.Length - vectorSize; i += vectorSize)
    {
        short[] charArray = new short[vectorSize];
        for (int j = 0; j < vectorSize; j++)
            charArray[j] = (short)text[i + j];
            
        Vector<short> chars = new Vector<short>(charArray);
        
        // Проверяем, что каждый символ находится в диапазоне '0'..'9'
        var greaterEqualThanZero = Vector.GreaterThanOrEqual(chars, zero);
        var lessEqualThanNine = Vector.LessThanOrEqual(chars, nine);
        var inRange = Vector.BitwiseAnd(greaterEqualThanZero, lessEqualThanNine);
        
        // Если хотя бы один символ не в диапазоне, возвращаем false
        if (Vector.EqualsAll(inRange, Vector<short>.Zero))
            return false;
    }
    
    // Проверяем оставшиеся символы
    for (; i < text.Length; i++)
    {
        if (text[i] < '0' || text[i] > '9')
            return false;
    }
    
    return true;
}

// Векторизованное вычисление префикс-функции для алгоритма КМП
public static int[] ComputePrefixFunction(ReadOnlySpan<char> pattern)
{
    int[] prefix = new int[pattern.Length];
    prefix[0] = 0;
    
    for (int i = 1; i < pattern.Length; i++)
    {
        int j = prefix[i - 1];
        
        while (j > 0 && pattern[i] != pattern[j])
            j = prefix[j - 1];
            
        prefix[i] = j + (pattern[i] == pattern[j] ? 1 : 0);
    }
    
    return prefix;
}