Quantitative Engineering

Geometric Control Variates & Thread Isolation in C++

Abstract: Implementation of closed-form geometric Control Variates to minimize standard error in Asian options, alongside the mitigation of CPU cache-line invalidation (False Sharing) in OpenMP environments.

1. Mathematical Foundation

In standard Monte Carlo option pricing, the estimator for the option's fair value converges at a slow rate of $$ \mathcal{O}(1/\sqrt{N}) $$. To drastically optimize computational precision without increasing the trajectory count, the Prometheus Engine implements the Control Variates variance reduction technique for Asian options.

The arithmetic average payoff possesses no closed-form analytical solution. However, the geometric average payoff does. By substituting the geometric mean, we can decompose the expected value as:

$$ E[Y_{arith}] = E[Y_{arith} - Y_{geom}] + E[Y_{geom}] $$

Because we calculate the exact analytical price for the geometric option, the simulation only needs to estimate the difference between the arithmetic and geometric payoffs. The variance of this new estimator is bounded by:

$$ Var(Y_{arith} - Y_{geom}) = Var(Y_{arith}) + Var(Y_{geom}) - 2Cov(Y_{arith}, Y_{geom}) $$

Since the arithmetic and geometric payoffs are highly correlated, the variance collapses significantly. The C++ engine computes the corrected payoff on a path-by-path basis, returning tighter Confidence Intervals (CI).

$$ Cov(Y_{arith}, Y_{geom}) \approx Var(Y_{geom}) \implies Var(Y_{arith} - Y_{geom}) \ll Var(Y_{arith}) $$

2. Low-Level Architecture & OpenMP

Parallelizing this algorithm in C++ introduces hardware-level constraints, specifically False Sharing.

When computing trajectories via OpenMP, multiple threads attempting to access a single global PRNG (Pseudo-Random Number Generator) state force the CPU to lock and invalidate cache lines across cores, creating a catastrophic I/O bottleneck.

To circumvent this, Prometheus enforces strict PRNG state isolation. Each thread initializes its own instance of the engine, seeded dynamically based on the thread ID:

#pragma omp parallel
{
    // Thread-local PRNG isolation to prevent False Sharing
    std::mt19937 engine(base_seed + omp_get_thread_num());
    std::normal_distribution<double> norm_dist(0.0, 1.0);
    
    #pragma omp for reduction(+:sum_payoffs, sum_payoffs_sq)
    for (int i = 0; i < N; ++i) {
        // Z is generated independently per thread
        double Z = norm_dist(engine);
    }
}

This architecture guarantees that scaling from 10,000 paths to 1,000,000,000 paths maintains perfectly linear computational efficiency.