A/B тестирование в C++: как не сломать продакшн и найти истину

Почему A/B тестирование — это не только про веб и маркетинг

Когда мы слышим «A/B тестирование», в голове всплывают лендинги, кнопки «Купить» и конверсии в Google Analytics. Но что, если ваш продукт — не сайт, а высоконагруженный сервер на C++, embedded-система или игровой движок? Можно ли здесь применять A/B тесты? Ещё как! И это не просто модный термин, а реальный инструмент для принятия решений на основе данных, а не интуиции.

В C++ A/B тестирование помогает ответить на вопросы: «Новый алгоритм сортировки действительно быстрее?», «Стоит ли вводить пул потоков?», «Улучшит ли новый формат сериализации время отклика API?». Без A/B теста вы рискуете внедрить «оптимизацию», которая на деле окажется регрессией. В этой статье мы разберём, как грамотно встроить механизм экспериментов в C++ код, не превратив его в лапшу из if-else.

Архитектура A/B теста в C++: без боли и страданий

Главная опасность A/B тестирования в C++ — засорить продакшн-код условными операторами. Чтобы этого избежать, нужно отделить логику эксперимента от бизнес-логики. Используем паттерн Feature Flag (фича-флаг) и стратегию. Рассмотрим базовую архитектуру.

Шаг 1: Централизованная конфигурация

Все флаги и параметры экспериментов храним в одном месте. Это может быть JSON-файл, база данных или удалённый конфиг-сервер. Для простоты возьмём JSON.

// experiment_config.json
{
  "experiments": {
    "sort_algorithm_v2": {
      "enabled": true,
      "variants": {
        "control": 50,
        "treatment": 50
      }
    },
    "memory_pool_size": {
      "enabled": true,
      "variants": {
        "default": 33,
        "pool_256": 33,
        "pool_512": 34
      }
    }
  }
}

Нагрузка (traffic split) задаётся в процентах. В C++ мы загружаем этот конфиг один раз при старте приложения.

Шаг 2: Класс-диспетчер экспериментов

Создадим потокобезопасный класс ExperimentManager, который по ключу (например, ID пользователя или транзакции) определяет, в какую группу попал объект.

#include <string>
#include <unordered_map>
#include <random>
#include <shared_mutex>
#include <nlohmann/json.hpp> // для парсинга JSON

class ExperimentManager {
public:
    explicit ExperimentManager(const std::string& config_path);
    
    // Возвращает имя варианта для заданного эксперимента и ключа
    std::string getVariant(const std::string& experiment_name, 
                           const std::string& user_id) const;

private:
    struct Experiment {
        bool enabled;
        std::vector<std::pair<std::string, int>> variants; // имя, вес
        int total_weight;
    };
    
    std::unordered_map<std::string, Experiment> experiments_;
    mutable std::shared_mutex mutex_;
    
    // Детерминированное хеширование для стабильного распределения
    size_t hashAndMod(const std::string& key, int mod) const;
};

// Реализация (упрощённо)
std::string ExperimentManager::getVariant(const std::string& exp_name,
                                          const std::string& user_id) const {
    std::shared_lock lock(mutex_);
    auto it = experiments_.find(exp_name);
    if (it == experiments_.end() || !it->second.enabled) {
        return "control"; // fallback
    }
    const auto& exp = it->second;
    size_t bucket = hashAndMod(user_id, exp.total_weight);
    int cumulative = 0;
    for (const auto& [name, weight] : exp.variants) {
        cumulative += weight;
        if (bucket < cumulative) {
            return name;
        }
    }
    return "control";
}

Важно: Используем детерминированное хеширование — один и тот же пользователь всегда попадает в одну группу. Это критично для корректности теста.

Практический пример: A/B тест нового алгоритма сортировки

Допустим, мы хотим проверить, ускорит ли новый алгоритм (например, TimSort вместо std::sort) обработку больших массивов. Вместо того чтобы переписывать весь код, мы внедряем точку выбора.

Код до A/B теста (монолит)

void processData(std::vector<int>& data) {
    std::sort(data.begin(), data.end()); // старый способ
    // ... дальнейшая обработка
}

Код после внедрения A/B теста

class Sorter {
public:
    virtual void sort(std::vector<int>& data) = 0;
    virtual ~Sorter() = default;
};

class StdSorter : public Sorter {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end());
    }
};

class TimSorter : public Sorter {
public:
    void sort(std::vector<int>& data) override {
        // реализация TimSort (упрощённо)
        timsort(data.begin(), data.end());
    }
};

// Фабрика, использующая ExperimentManager
std::unique_ptr<Sorter> createSorter(const ExperimentManager& mgr,
                                     const std::string& user_id) {
    std::string variant = mgr.getVariant("sort_algorithm_v2", user_id);
    if (variant == "treatment") {
        return std::make_unique<TimSorter>();
    }
    return std::make_unique<StdSorter>();
}

void processData(std::vector<int>& data, const ExperimentManager& mgr,
                 const std::string& user_id) {
    auto sorter = createSorter(mgr, user_id);
    sorter->sort(data);
    // ... дальнейшая обработка
}

Теперь 50% пользователей видят новый алгоритм. Мы собираем метрики: время выполнения, загрузку CPU, потребление памяти. Через неделю смотрим статистику.

Сбор метрик и статистическая значимость

Мало просто разделить трафик — нужно замерить результат. В C++ для сбора метрик удобно использовать гистограммы и микро-бенчмарки. Пример простого таймера:

#include <chrono>
#include <vector>

class ScopedTimer {
public:
    ScopedTimer(std::vector<double>& dest) : dest_(dest), start_(std::chrono::high_resolution_clock::now()) {}
    ~ScopedTimer() {
        auto end = std::chrono::high_resolution_clock::now();
        double elapsed = std::chrono::duration<double, std::milli>(end - start_).count();
        dest_.push_back(elapsed);
    }
private:
    std::vector<double>& dest_;
    std::chrono::time_point<std::chrono::high_resolution_clock> start_;
};

// Использование:
std::vector<double> latencies_control;
std::vector<double> latencies_treatment;

// В точке замера:
if (variant == "control") {
    ScopedTimer t(latencies_control);
    // ... работа
} else {
    ScopedTimer t(latencies_t