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

// Время выполнения зависит от предсказуемости ветвлений
void ProcessArray(int[] data, int threshold)
{
  int sum = 0;
  for (int i = 0; i < data.Length; i++)
  {
      // Условный переход - потенциально непредсказуемое ветвление
      if (data[i] > threshold)
          sum += data[i];
  }
  return sum;
}

// Сначала сортируем, затем обрабатываем
Array.Sort(data);
int sum = 0;
int i = 0;
// Пропускаем все элементы ниже порога
while (i < data.Length && data[i] <= threshold)
    i++;
// Обрабатываем все элементы выше порога без условий
for (; i < data.Length; i++)
    sum += data[i];

// Вместо этого (непредсказуемое ветвление)
int max = x > y ? x : y;
 
// Используйте это (без ветвлений)
int diff = x - y;
int mask = diff >> 31; // Будет -1 если x < y, иначе 0
int max = x - (diff & mask);

// Плохо для предсказания (ранний выход)
bool Contains(int[] array, int value)
{
  for (int i = 0; i < array.Length; i++)
  {
      if (array[i] == value)
          return true; // Неожиданный выход из цикла
  }
  return false;
}
 
// Лучше (если применимо)
bool Contains(int[] sortedArray, int value)
{
  int index = Array.BinarySearch(sortedArray, value);
  return index >= 0;
}

// Вместо множества условий
string GetDayName(int dayOfWeek)
{
  return dayOfWeek switch
  {
      0 => "Monday",
      1 => "Tuesday",
      // ...и так далее
  };
}
 
// Используйте таблицу
private static readonly string[] DayNames = 
    { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
string GetDayName(int dayOfWeek)
{
  return DayNames[dayOfWeek];
}

void Process(Data item)
{
  // Основной путь выполнения (горячий)
  if (!Validate(item))
  {
      HandleInvalidItem(item); // Редкий случай (холодный)
      return;
  }
  
  // Продолжение основного пути
}
 
[MethodImpl(MethodImplOptions.NoInlining)]
void HandleInvalidItem(Data item)
{
  // Обработка редких случаев
}

// Асинхронный метод, трансформируемый компилятором в конечный автомат
async Task<int> ProcessDataAsync(Data[] items)
{
    int result = 0;
    foreach (var item in items)
    {
        if (item.RequiresExternalProcessing)
            result += await ProcessExternallyAsync(item); // Точка ветвления и ожидания
        else
            result += ProcessLocally(item);
    }
    return result;
}

// Лучше для предсказания ветвлений
async Task<int> ProcessDataOptimizedAsync(Data[] items)
{
    // Разделяем элементы, требующие разной обработки
    var localItems = new List<Data>();
    var externalItems = new List<Data>();
    
    foreach (var item in items)
    {
        if (item.RequiresExternalProcessing)
            externalItems.Add(item);
        else
            localItems.Add(item);
    }
    
    // Обрабатываем локальные элементы без асинхронности
    int localResult = 0;
    foreach (var item in localItems)
        localResult += ProcessLocally(item);
    
    // Обрабатываем внешние элементы асинхронно
    var externalTasks = externalItems.Select(ProcessExternallyAsync);
    var externalResults = await Task.WhenAll(externalTasks);
    int externalResult = externalResults.Sum();
    
    return localResult + externalResult;
}

private readonly ConcurrentDictionary<string, Task<Result>> _resultCache = new();
 
async Task<Result> GetDataWithCachingAsync(string key)
{
    return await _resultCache.GetOrAdd(key, k => FetchDataAsync(k));
}

// Вместо этого
void ProcessShape(Shape shape)
{
    switch (shape.Type)
    {
        case ShapeType.Circle:
            ProcessCircle((Circle)shape);
            break;
        case ShapeType.Rectangle:
            ProcessRectangle((Rectangle)shape);
            break;
        // ...и так далее
    }
}
 
// Используйте это
abstract class Shape
{
    public abstract void Process();
}
 
class Circle : Shape
{
    public override void Process() { /* Реализация для круга */ }
}
 
class Rectangle : Shape
{
    public override void Process() { /* Реализация для прямоугольника */ }
}

// Вместо проверки на null
public int CalculateValue(Data data)
{
    if (data == null)
        return 0;
    return data.Value * 10;
}
 
// Используйте Nullable<T> и операторы объединения с null
public int CalculateValue(Data? data)
{
    return (data?.Value ?? 0) * 10;
}

// Классическое условное присвоение минимального значения
int Min(int a, int b)
{
    if (a < b)
        return a;
    else
        return b;
}
 
// Версия без ветвлений, использующая битовую маску
int MinBranchless(int a, int b)
{
    int diff = a - b;
    int mask = diff >> 31; // -1 если a < b, иначе 0
    return b + (diff & mask);
}

// Проверка чётности с ветвлением
bool IsEvenWithBranch(int value)
{
    return value % 2 == 0;
}
 
// Проверка чётности без ветвления
bool IsEvenBranchless(int value)
{
    return (value & 1) == 0;
}
 
// Модуль числа с ветвлением
int AbsWithBranch(int value)
{
    return value < 0 ? -value : value;
}
 
// Модуль числа без ветвления
int AbsBranchless(int value)
{
    int mask = value >> 31; // -1 для отрицательных чисел, 0 для положительных
    return (value ^ mask) - mask;
}

// Функция с ветвлением
float DivideWithBranch(float a, float b)
{
    if (b == 0)
        return float.MaxValue; // Защита от деления на ноль
    return a / b;
}
 
// Функция без ветвления, но с вычислением обоих путей
float DivideBranchless(float a, float b)
{
    bool isZero = b == 0;
    
    // Вычисляем оба значения
    float normalResult = a / (b + (isZero ? float.Epsilon : 0));
    float fallbackResult = float.MaxValue;
    
    // Выбираем нужное без ветвления
    return isZero ? fallbackResult : normalResult;
}

// JIT может встроить этот метод в вызывающий код
[MethodImpl(MethodImplOptions.AggressiveInlining)]
int Square(int x) => x * x;

// JIT может полностью удалить ветвь с константами
if (false)
{
    // Этот код никогда не выполнится
    DoSomething();
}

// JIT может развернуть этот цикл в последовательность операций
int sum = 0;
for (int i = 0; i < 4; i++)
{
    sum += array[i];
}
 
// Превращается примерно в:
int sum = 0;
sum += array[0];
sum += array[1];
sum += array[2];
sum += array[3];

public int Classify(float[] features)
{
    if (features[0] > 0.5f)
    {
        if (features[1] > 0.3f)
            return 1;
        else
            return 2;
    }
    else
    {
        if (features[3] > 0.7f)
            return 3;
        else
            return 4;
    }
}

// После анализа данных мы выяснили, что features[1] > 0.3f имеет
// наибольшую дискриминационную способность
public int ClassifyOptimized(float[] features)
{
    if (features[1] > 0.3f)
    {
        if (features[0] > 0.5f)
            return 1;
        else
            return 0; // новый результат для этой комбинации
    }
    else
    {
        if (features[0] > 0.5f)
            return 2;
        else if (features[3] > 0.7f)
            return 3;
        else
            return 4;
    }
}

// Код, оптимальный для одной архитектуры, может быть неоптимальным для другой
public void ProcessCrossplatform(int[] data)
{
    // На x86 этот цикл может быть более эффективным
    if (RuntimeInformation.ProcessArchitecture == Architecture.X86 ||
        RuntimeInformation.ProcessArchitecture == Architecture.X64)
    {
        for (int i = 0; i < data.Length; i++)
        {
            if (data[i] > 0) // Непредсказуемое ветвление
                Process(data[i]);
        }
    }
    else
    {
        // На ARM может быть лучше сначала отфильтровать данные
        var filtered = data.Where(x => x > 0).ToArray();
        foreach (var item in filtered)
            Process(item);
    }
}

// C#-код
if (value > threshold)
    result = value;
else
    result = threshold;
 
// Примерный ассемблерный код, который может сгенерировать JIT
// (упрощённо, реальный код будет отличаться)
mov eax, [value]     // Загружаем value в регистр eax
cmp eax, [threshold] // Сравниваем с threshold
jle else_branch      // Переходим на else_branch, если value <= threshold
mov [result], eax    // result = value
jmp end              // Прыгаем в конец условного блока
else_branch:
mov eax, [threshold] // Загружаем threshold в eax
mov [result], eax    // result = threshold
end:

// Более предсказуемые ветвления с целыми числами
if (intValue > 100)
    DoSomething();
 
// Менее предсказуемые с плавающей точкой из-за особенностей представления
if (floatValue > 100.0f)
    DoSomething();
 
// Ещё менее предсказуемые со строками из-за сложности сравнения
if (string.Compare(strValue, "threshold") > 0)
    DoSomething();

// Преобразуем строку в целочисленное представление один раз
int strHash = strValue.GetHashCode();
// Затем используем числовое сравнение, которое более эффективно
if (strHash > cachedThresholdHash)
    DoSomething();

// До рефакторинга
if (condition)
    DoRareCase();
else
    DoCommonCase();
 
// После рефакторинга
if (!condition)
    DoCommonCase();
else
    DoRareCase();

// До рефакторинга
if (condition1)
{
    if (condition2)
    {
        // Вложенный код
    }
    else
    {
        // Ещё код
    }
}
else
{
    // Альтернативный код
}
 
// После рефакторинга
if (!condition1)
    return AlternativeResult();
if (!condition2)
    return ElseResult();
return MainResult();

// До рефакторинга
int result;
if (value == 1) result = 10;
else if (value == 2) result = 20;
else if (value == 3) result = 30;
else result = 0;
 
// После рефакторинга
int[] lookupTable = { 0, 10, 20, 30 };
int result = value >= 1 && value <= 3 ? lookupTable[value] : 0;

// Потенциально непредсказуемые ветвления из-за взаимодействия с GC
if (GetComplexObject().Property > threshold)
    DoSomething();

// Более предсказуемые ветвления
var obj = GetComplexObject(); // Аллокация происходит до условия
if (obj.Property > threshold)
    DoSomething();

long Factorial(int n)
{
    if (n <= 1) // Условие выхода из рекурсии
        return 1;
    return n * Factorial(n - 1);
}

long FactorialIterative(int n)
{
    long result = 1;
    for (int i = 2; i <= n; i++)
        result *= i;
    return result;
}

void TraverseTreeIterative(TreeNode root)
{
    if (root == null) return;
    
    var stack = new Stack<TreeNode>();
    stack.Push(root);
    
    while (stack.Count > 0)
    {
        var node = stack.Pop();
        
        // Обработка узла
        Process(node);
        
        // Добавляем потомков в обратном порядке
        if (node.Right != null)
            stack.Push(node.Right);
        if (node.Left != null)
            stack.Push(node.Left);
    }
}

long FactorialTailRecursive(int n, long accumulator = 1)
{
    if (n <= 1)
        return accumulator;
    
    // Это хвостовой рекурсивный вызов, который оптимизируется в цикл
    return FactorialTailRecursive(n - 1, n * accumulator);
}

// Императивный подход с множеством условий
List<Customer> FilterCustomers(List<Customer> customers)
{
    var result = new List<Customer>();
    foreach (var customer in customers)
    {
        if (customer.Age >= 18 && customer.Orders.Count > 5 && 
            customer.TotalSpent > 1000 && !customer.IsBlacklisted)
        {
            result.Add(customer);
        }
    }
    return result;
}
 
// Декларативный подход с LINQ
List<Customer> FilterCustomersDeclarative(List<Customer> customers)
{
    return customers
        .Where(c => c.Age >= 18)
        .Where(c => c.Orders.Count > 5)
        .Where(c => c.TotalSpent > 1000)
        .Where(c => !c.IsBlacklisted)
        .ToList();
}

using Microsoft.Diagnostics.Tracing.Parsers;
using Microsoft.Diagnostics.Tracing.Session;
 
void MeasureBranchMispredictions()
{
    using (var session = new TraceEventSession("BranchAnalysis"))
    {
        session.EnableProvider(ClrTraceEventParser.ProviderGuid,
            TraceEventLevel.Verbose,
            (ulong)(ClrTraceEventParser.Keywords.JitTracing |
                  ClrTraceEventParser.Keywords.JittedMethodILToNativeMap));
        
        // Запускаем тестируемый код
        RunTest();
        
        // Анализируем собранные данные
        // ...
    }
}

using System.Diagnostics.Tracing;
 
[EventSource(Name = "BranchPredictionMetrics")]
public sealed class BranchMetricsEventSource : EventSource
{
    public static readonly BranchMetricsEventSource Log = new BranchMetricsEventSource();
    
    [Event(1)]
    public void ReportMispredictions(string methodName, long mispredictions)
    {
        WriteEvent(1, methodName, mispredictions);
    }
}

abstract class Animal
{
    public abstract void MakeSound(); // Виртуальный метод
}
 
class Dog : Animal
{
    public override void MakeSound() { Console.WriteLine("Woof!"); }
}
 
class Cat : Animal
{
    public override void MakeSound() { Console.WriteLine("Meow!"); }
}

// Вместо этого (непредсказуемые переходы между разными реализациями)
foreach (var animal in mixedAnimals)
    animal.MakeSound();
 
// Сначала группируем по типам, затем обрабатываем
var animalsByType = mixedAnimals.GroupBy(a => a.GetType());
foreach (var group in animalsByType)
    foreach (var animal in group)
        animal.MakeSound();

// Для ограниченного набора известных типов можно использовать pattern matching
void ProcessAnimal(Animal animal)
{
    switch (animal)
    {
        case Dog dog:
            // Прямой невиртуальный вызов, лучше для предсказания
            dog.MakeSound();
            break;
        case Cat cat:
            cat.MakeSound();
            break;
        default:
            // Виртуальный вызов только для редких случаев
            animal.MakeSound();
            break;
    }
}

// Может компилироваться в цепочку if-else
switch (value)
{
    case 0: DoAction0(); break;
    case 1: DoAction1(); break;
    case 2: DoAction2(); break;
    // и так далее
}

// Определяем таблицу действий
private static readonly Action[] ActionTable = 
{
    DoAction0,
    DoAction1,
    DoAction2,
    // и так далее
};
 
// Используем прямой доступ по индексу вместо множественных условий
void ProcessValue(int value)
{
    if (value >= 0 && value < ActionTable.Length)
        ActionTable[value]();
    else
        HandleDefaultCase();
}

// Практический пример для обработки HTTP-запросов
private static readonly Dictionary<string, RequestHandler> _handlers = new()
{
    ["/api/users"] = HandleUsers,
    ["/api/products"] = HandleProducts,
    ["/api/orders"] = HandleOrders,
    // и т.д.
};
 
void ProcessRequest(HttpRequest request)
{
    if (_handlers.TryGetValue(request.Path, out var handler))
        handler(request);
    else
        HandleNotFound(request);
}

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    [HttpGet("{id}")]
    public ActionResult<Order> GetOrder(int id)
    {
        var order = _repository.GetOrder(id);
        if (order == null)
            return NotFound();
        
        if (!User.HasPermission(PermissionType.ViewOrder))
            return Forbid();
        
        if (order.Status == OrderStatus.Deleted)
            return BadRequest("Order was deleted");
            
        return order;
    }
    
    // Другие методы...
}

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    [HttpGet("{id}")]
    public ActionResult<Order> GetOrder(int id)
    {
        // Проверяем наиболее вероятный сценарий отказа первым
        if (!User.HasPermission(PermissionType.ViewOrder))
            return Forbid();
        
        var order = _repository.GetOrder(id);
        if (order == null)
            return NotFound();
        
        // Используем битовую маску для проверки статуса вместо сравнения enum
        // OrderStatus.Deleted может быть представлен как битовый флаг
        if ((order.StatusFlags & DeletedFlag) != 0)
            return BadRequest("Order was deleted");
            
        return order;
    }
}

// Оптимизированный middleware с учетом предсказания ветвлений
public class OptimizedAuthMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string[] _publicPaths;
    private readonly string[] _adminPaths;
    
    public OptimizedAuthMiddleware(RequestDelegate next)
    {
        _next = next;
        _publicPaths = new[] { "/api/public", "/health", "/metrics" };
        _adminPaths = new[] { "/api/admin", "/management" };
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Используем таблицу быстрого поиска для определения типа пути
        PathType pathType = GetPathType(context.Request.Path);
        
        // Один условный переход вместо множественных проверок
        switch (pathType)
        {
            case PathType.Public:
                await _next(context);
                break;
            case PathType.Admin:
                if (IsAdmin(context.User))
                    await _next(context);
                else
                    context.Response.StatusCode = 403;
                break;
            default: // Authenticated
                if (context.User.Identity.IsAuthenticated)
                    await _next(context);
                else
                    context.Response.StatusCode = 401;
                break;
        }
    }
    
    private PathType GetPathType(PathString path)
    {
        // Хэшируем пути для быстрого поиска
        string pathStr = path.ToString().ToLowerInvariant();
        
        if (_publicPathsSet.Contains(pathStr))
            return PathType.Public;
            
        if (_adminPathsSet.Contains(pathStr))
            return PathType.Admin;
            
        return PathType.Authenticated;
    }
    
    private enum PathType { Public, Admin, Authenticated }
}

[Benchmark]
[Arguments(1000, 0.1f)] // 10% элементов выше порога
[Arguments(1000, 0.5f)] // 50% элементов выше порога
[Arguments(1000, 0.9f)] // 90% элементов выше порога
public int FilterArrayOriginal(int count, float aboveThresholdRatio)
{
    int[] data = GenerateTestData(count, aboveThresholdRatio);
    int result = 0;
    
    for (int i = 0; i < data.Length; i++)
    {
        if (data[i] > Threshold)
            result += data[i];
    }
    
    return result;
}
 
[Benchmark]
[Arguments(1000, 0.1f)]
[Arguments(1000, 0.5f)]
[Arguments(1000, 0.9f)]
public int FilterArrayOptimized(int count, float aboveThresholdRatio)
{
    // Оптимизированная версия алгоритма
    // ...
}

[Benchmark]
[HardwareCounters(HardwareCounter.BranchInstructions, 
                 HardwareCounter.BranchMispredictions)]
public void OriginalAlgorithm()
{
    // Исходная реализация
}
 
[Benchmark]
[HardwareCounters(HardwareCounter.BranchInstructions, 
                 HardwareCounter.BranchMispredictions)]
public void OptimizedAlgorithm()
{
    // Оптимизированная реализация
}

[Test]
public void EnsureNoRegressionInBranchPrediction()
{
    // Запускаем оптимизированный и оригинальный алгоритмы с 
    // одинаковыми данными и измеряем метрики
    
    Assert.Less(
        optimizedResult.Metrics["BranchMispredictions"] / optimizedResult.Metrics["BranchInstructions"],
        originalResult.Metrics["BranchMispredictions"] / originalResult.Metrics["BranchInstructions"] * 1.05,
        "Коэффициент промахов предсказателя не должен увеличиваться более чем на 5%"
    );
}

// Упрощенная версия парсера JSON с множеством ветвлений
char NextToken(string json, ref int position)
{
    // Пропускаем пробелы
    while (position < json.Length && char.IsWhiteSpace(json[position]))
        position++;
        
    if (position >= json.Length)
        return '\0';
    
    char c = json[position++];
    
    // Множественные условия для определения типа токена
    switch (c)
    {
        case '{':
        case '}':
        case '[':
        case ']':
        case ':':
        case ',':
            return c;
        case '"':
            // Обработка строки
            // ...
            return '"';
        case 't':
            // Проверка на "true"
            if (position + 3 <= json.Length && 
                json[position] == 'r' && 
                json[position + 1] == 'u' && 
                json[position + 2] == 'e')
            {
                position += 3;
                return 't';
            }
            throw new FormatException("Unexpected token");
        // И много других условий
    }
    
    // ...
}

int FindNextSpecialChar(string json, int startPos)
{
    Vector<short> quotesVector = new Vector<short>('"');
    Vector<short> braceOpenVector = new Vector<short>('{');
    Vector<short> braceCloseVector = new Vector<short>('}');
    // и другие специальные символы...
    
    int vectorSize = Vector<short>.Count;
    for (int i = startPos; i <= json.Length - vectorSize; i += vectorSize)
    {
        short[] buffer = new short[vectorSize];
        for (int j = 0; j < vectorSize; j++)
            buffer[j] = (short)json[i + j];
            
        var chars = new Vector<short>(buffer);
        
        // Проверяем несколько специальных символов одновременно
        var quotesMatches = Vector.Equals(chars, quotesVector);
        var braceOpenMatches = Vector.Equals(chars, braceOpenVector);
        var braceCloseMatches = Vector.Equals(chars, braceCloseVector);
        
        // Объединяем результаты
        var allMatches = Vector.BitwiseOr(
            Vector.BitwiseOr(quotesMatches, braceOpenMatches),
            braceCloseMatches
        );
        
        if (allMatches != Vector<short>.Zero)
        {
            // Нашли специальный символ, определяем его позицию
            for (int j = 0; j < vectorSize; j++)
            {
                if (quotesMatches[j] != 0 || braceOpenMatches[j] != 0 || 
                    braceCloseMatches[j] != 0)
                {
                    return i + j;
                }
            }
        }
    }
    
    // Проверяем оставшиеся символы традиционным способом
    // ...
}

enum ParserState { Start, InString, AfterColon, InNumber, /* ... */ }
 
class OptimizedJsonParser
{
    // Таблица переходов: [текущее состояние][входной символ] -> новое состояние
    private static readonly ParserState[,] _transitionTable;
    
    // Таблица действий: [текущее состояние][входной символ] -> действие
    private static readonly Action<ParserContext>[,] _actionTable;
    
    static OptimizedJsonParser()
    {
        // Инициализируем таблицы переходов и действий
        _transitionTable = new ParserState[Enum.GetValues(typeof(ParserState)).Length, 128];
        _actionTable = new Action<ParserContext>[Enum.GetValues(typeof(ParserState)).Length, 128];
        
        // Заполняем таблицы
        // Например, переход из состояния Start по символу '{'
        _transitionTable[(int)ParserState.Start, '{'] = ParserState.AfterObjectOpen;
        _actionTable[(int)ParserState.Start, '{'] = ctx => ctx.StartObject();
        
        // ... и так далее для всех комбинаций
    }
    
    public void Parse(string json)
    {
        var ctx = new ParserContext();
        ParserState state = ParserState.Start;
        
        for (int i = 0; i < json.Length; i++)
        {
            char c = json[i];
            if (c < 128) // ASCII-символы
            {
                // Используем таблицу для определения следующего состояния и действия
                var action = _actionTable[(int)state, c];
                state = _transitionTable[(int)state, c];
                
                // Выполняем соответствующее действие, если оно определено
                action?.Invoke(ctx);
            }
            else
            {
                // Для не-ASCII символов используем запасной алгоритм
                HandleNonAscii(ctx, c, ref state);
            }
        }
    }
}

// Традиционный тернарный оператор
int SelectByCondition(bool condition, int trueValue, int falseValue)
{
    return condition ? trueValue : falseValue;
}
 
// Битовая реализация, которая трансформируется в CMOV
int SelectByConditionOptimized(bool condition, int trueValue, int falseValue)
{
    // Превращаем bool в маску (0 или -1)
    int mask = -(condition ? 1 : 0);
    
    // Используем битовую арифметику: (mask & trueValue) | (~mask & falseValue)
    return (mask & trueValue) | (~mask & falseValue);
}

// Оптимизация вычисления знака числа
int SignOf(int value)
{
    // Вместо условной логики:
    // if (value > 0) return 1;
    // else if (value < 0) return -1;
    // else return 0;
    
    // Используем битовые операции:
    // Для положительных чисел: 1
    // Для отрицательных: -1
    // Для нуля: 0
    return (value > 0 ? 1 : 0) - (value < 0 ? 1 : 0);
}

int BinarySearch(int[] sortedArray, int target)
{
    int left = 0;
    int right = sortedArray.Length - 1;
    
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        
        if (sortedArray[mid] == target)
            return mid;
            
        if (sortedArray[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    
    return -1;
}

int BinarySearchOptimized(int[] sortedArray, int target)
{
    int left = 0;
    int right = sortedArray.Length - 1;
    
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        
        // Если нашли точное совпадение, возвращаем результат
        if (sortedArray[mid] == target)
            return mid;
            
        // Определяем направление поиска без второго условия
        bool goRight = sortedArray[mid] < target;
        
        // Используем арифметику вместо условия
        left += goRight ? (mid - left + 1) : 0;
        right -= !goRight ? (right - mid + 1) : 0;
    }
    
    return -1;
}

int InterpolationSearch(int[] array, int target)
{
    int low = 0;
    int high = array.Length - 1;
    
    while (low <= high && target >= array[low] && target <= array[high])
    {
        // Используем интерполяцию для предположения позиции
        int pos = low + ((target - array[low]) * (high - low)) / 
                 (array[high] - array[low]);
        
        // Предотвращаем выход за границы
        pos = Math.Min(Math.Max(pos, low), high);
        
        if (array[pos] == target)
            return pos;
            
        // Вместо обычного условия используем арифметику и битовые операции
        // для определения направления поиска
        bool isLess = array[pos] < target;
        low += isLess ? (pos - low + 1) : 0;
        high -= !isLess ? (high - pos + 1) : 0;
    }
    
    return -1;
}

async Task<Response> ProcessRequestAsync(Request request)
{
    var serviceAResult = await _serviceAClient.GetDataAsync(request.Id);
    var serviceBResult = await _serviceBClient.GetDataAsync(request.Id);
    
    // Множественные условия для определения типа ответа
    if (serviceAResult.Status == Status.Error || serviceBResult.Status == Status.Error)
        return ErrorResponse();
        
    if (serviceAResult.Data?.Value > Threshold && 
        serviceBResult.Data?.IsApproved == true)
    {
        return SuccessResponse(serviceAResult.Data, serviceBResult.Data);
    }
    else if (serviceAResult.Data?.Value <= Threshold)
    {
        return ThresholdNotMetResponse();
    }
    else
    {
        return NotApprovedResponse();
    }
}

async Task<Response> ProcessRequestOptimizedAsync(Request request)
{
    // Параллельные запросы для минимизации задержки
    var serviceATask = _serviceAClient.GetDataAsync(request.Id);
    var serviceBTask = _serviceBClient.GetDataAsync(request.Id);
    
    await Task.WhenAll(serviceATask, serviceBTask);
    
    var serviceAResult = serviceATask.Result;
    var serviceBResult = serviceBTask.Result;
    
    // Проверяем наиболее частый сценарий отказа первым
    if (serviceAResult.Status == Status.Error || serviceBResult.Status == Status.Error)
        return ErrorResponse();
    
    // Упрощаем логику с использованием промежуточных переменных
    bool thresholdMet = serviceAResult.Data?.Value > Threshold;
    bool isApproved = serviceBResult.Data?.IsApproved == true;
    
    // Используем индексированный доступ к таблице ответов
    // вместо вложенных условий
    return _responseMatrix[thresholdMet ? 1 : 0, isApproved ? 1 : 0];
}
 
// Таблица предварительно настроенных ответов
private readonly Response[,] _responseMatrix = {
    { NotApprovedResponse(), ThresholdNotMetResponse() },
    { NotApprovedResponse(), SuccessResponse(/* параметры по умолчанию */) }
};

// До оптимизации: множество точек await
async Task<int> ProcessDataAsync(Data[] items)
{
    int result = 0;
    foreach (var item in items)
    {
        if (await ShouldProcessAsync(item))
        {
            result += await ProcessItemAsync(item);
        }
    }
    return result;
}
 
// После оптимизации: меньше точек await
async Task<int> ProcessDataOptimizedAsync(Data[] items)
{
    // Предварительно определяем, какие элементы нужно обработать
    var filterTasks = items.Select(item => ShouldProcessAsync(item)).ToArray();
    await Task.WhenAll(filterTasks);
    
    // Отбираем только те элементы, которые нужно обработать
    var filteredItems = items
        .Zip(filterTasks, (item, task) => (item, shouldProcess: task.Result))
        .Where(tuple => tuple.shouldProcess)
        .Select(tuple => tuple.item)
        .ToArray();
    
    // Обрабатываем отфильтрованные элементы пакетно
    var processTasks = filteredItems.Select(ProcessItemAsync).ToArray();
    var results = await Task.WhenAll(processTasks);
    
    return results.Sum();
}

// Уязвимая реализация: время выполнения зависит от секретного ключа
bool CompareHMAC(byte[] expected, byte[] actual)
{
    if (expected.Length != actual.Length)
        return false;
        
    for (int i = 0; i < expected.Length; i++)
    {
        if (expected[i] != actual[i])
            return false; // Раннее возвращение раскрывает позицию несовпадения
    }
    
    return true;
}
 
// Защищённая реализация: время выполнения не зависит от секретного ключа
bool CompareHMACSecure(byte[] expected, byte[] actual)
{
    if (expected.Length != actual.Length)
        return false;
        
    int result = 0;
    for (int i = 0; i < expected.Length; i++)
    {
        // XOR аккумулирует различия, не раскрывая их позиции
        result |= expected[i] ^ actual[i];
    }
    
    return result == 0; // Единственная точка ветвления
}