XVA Sensitivities
AADC vs Bump & Revalue

// XVAJobRequest.h, compileAADFunction()

void compileAADFunction(const json& request_data) {
    // Random variables as input (no derivatives needed for these)
    std::vector<idouble> aad_random_vec(XVA.numberOfRandomVars());

    m_aad_funcs->startRecording();

        // Mark random inputs
        markVectorAsInput(m_random_arg, aad_random_vec, false);

        // Mark market data as variable inputs (can change without recompilation)
        markVariableInputs(getArgumentsMap(), true);

        // Create the XVA problem with aadc::idouble, same code as double version
        XVAProblem<idouble> aad_XVA;
        aad_XVA.initData(m_data);

        idouble::CheckPoint();

        // Mark EVERY risk factor as its own input (one-time setup).
        // Each input remembers where its value comes from, so the compiled
        // kernel is fed the current market data on every run.
        auto markPoint = [&](const idouble& v, const std::string& json_path) {
            aadc::AADCArgument arg = v.markAsInput();
            m_point_inputs.push_back({arg, json_path});
            return arg;
        };
        m_xva_diff_args.ir_crvs[0].r0    = markPoint(aad_XVA.getModel()->getR0(), "/Currencies/EUR/r0");
        m_xva_diff_args.ir_crvs[0].sigma = markPoint(aad_XVA.getModel()->getSigma(), "/Currencies/EUR/sigma");
        for (int i = 0; i < meanRevSize; i++)                    // 250 points
            m_xva_diff_args.ir_crvs[0].mr_crv.push_back(markPoint(
                aad_XVA.getModel()->getMeanRev()->getVals()[i],
                "/Currencies/EUR/HWMeanReversionCurve/flat_rate"));
        for (int i = 0; i < survivalCurveSize; i++)              // 140 points
            m_xva_diff_args.company_surv_crv.default_rates.push_back(markPoint(
                aad_XVA.getCompSurvCurv()->getZeroRatesVector()[i],
                "/CompanySurvivalCurve/flat_rate"));
        // ... counterparty survival curve, 140 points, same pattern ...

        // Record ONE forward pass (same simulatePath + computeXVAMeasures)
        aad_XVA.prepareSimulations();
        aad_XVA.simulatePath(aad_random_vec);
        aad_XVA.computeXVAMeasures();

        // Mark outputs
        m_res_args.CVA = aad_XVA.getCVA().markAsOutput();
        m_res_args.DVA = aad_XVA.getDVA().markAsOutput();

    m_aad_funcs->stopRecording();
    // Kernel is now compiled to optimised AVX2/AVX-512 machine code
}

// XVAJobRequest.h, aADExecution()

void aADExecution(const json& request_data, int threads_num) {
    auto threadWorker = [&](int th_i) {
        // Each thread gets its own AADC workspace
        auto ws = m_aad_funcs->createWorkSpace();

        // Set market data inputs (can update without recompilation)
        for (auto& [path, arg] : request_variable_inputs)
            ws->val(arg.second) = mmSetConst<mmType>(request_data[path]);
        // Set every risk-factor input from the current request
        for (auto& [arg, path] : m_point_inputs)
            ws->val(arg) = mmSetConst<mmType>(request_data[path]);

        m_aad_funcs->forward(*ws, 0, 0);  // Initialise once

        for (int mc_i = 0; mc_i < AVX_iterations; mc_i++) {
            // Set random numbers (4 paths at once with AVX-256)
            setAVXVector(*ws, m_random_arg, mm_randoms[mc_i + AVX_iterations * th_i]);

            // Forward sweep: computes prices for 4 MC paths simultaneously
            m_aad_funcs->forward(*ws, 1, -1);

            // Reverse sweep for CVA sensitivities (ALL 532 gradients at once)
            ws->resetDiff();
            ws->diff(m_res_args.CVA) = mmSetConst<mmType>(1);
            m_aad_funcs->reverse(*ws, 1, -1);

            // Reverse sweep for DVA sensitivities (ALL 532 gradients at once)
            ws->resetDiff();
            ws->diff(m_res_args.DVA) = mmSetConst<mmType>(1);
            m_aad_funcs->reverse(*ws, 1, -1);
        }
    };

    // Launch threads, each processes its share of MC paths
    for (int i = 0; i < threads_num; i++)
        threads.push_back(new std::thread(threadWorker, i));
    for (auto& t : threads) t->join();
}

// Kernel caching: zero-cost market data updates
void processRequest(const json& request_data, ...) {
    auto cached = find_in_cache(m_data);
    if (cached != cache.end()) {
        m_aad_funcs = cached->aad_funcs;  // REUSE: ~0ms
    } else {
        compileAADFunction(request_data);  // COMPILE: 1.2-5.5s (5 threads)
        cache.push_back(new_kernel);
    }
    aADExecution(request_data, threads_num);
}