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 ALL risk factors for differentiation (one-time setup)
        m_xva_diff_args.ir_crvs[0].r0    = aad_XVA.getModel()->getR0().markAsDiff();
        m_xva_diff_args.ir_crvs[0].sigma  = aad_XVA.getModel()->getSigma().markAsDiff();
        for (int i = 0; i < meanRevSize; i++)
            m_xva_diff_args.ir_crvs[0].mr_crv.push_back(
                aad_XVA.getModel()->getMeanRev()->getVals()[i].markAsDiff());
        for (int i = 0; i < survivalCurveSize; i++)
            m_xva_diff_args.company_surv_crv.default_rates.push_back(
                aad_XVA.getCompSurvCurv()->getZeroRatesVector()[i].markAsDiff());
        // ... counterparty survival curve ...

        // 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 optimized 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]);

        m_aad_funcs->forward(*ws, 0, 0);  // Initialize 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 535 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 535 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-8s
        cache.push_back(new_kernel);
    }
    aADExecution(request_data, threads_num);
}