NVHPC Compiler support

[pedronahum]

Hi,

Wanted to play with the library, but it looks like as of now the NVC++ compiler is currently not supported.

1. The freestanding tests would fail to compile. If not MSVC may need to be extended to also exclude NVHPC.

2. The memory layout of the NVIDIA HPC compiler may be different from the other compilers as several static assertions are failing.

proxy/tests/proxy_traits_tests.cpp", line 47: error: static assertion failed
  static_assert(sizeof(pro::proxy<DefaultFacade>) == 4 * sizeof(void*));  // VTABLE should be embeded
  ^

"/proxy/tests/proxy_traits_tests.cpp", line 74: error: static assertion failed
  static_assert(sizeof(pro::proxy<DefaultFacade>) == 4 * sizeof(void*));  // VTABLE should be embeded
  ^

"/proxy/tests/proxy_traits_tests.cpp", line 104: error: static assertion failed
  static_assert(sizeof(pro::proxy<CopyableFacade>) == 3 * sizeof(void*));  // VTABLE should not be embeded
  ^

"/proxy/tests/proxy_traits_tests.cpp", line 125: error: static assertion failed
  static_assert(sizeof(pro::proxy<CopyableSmallFacade>) == 2 * sizeof(void*));  // VTABLE should not be embeded
  ^

"/proxy/tests/proxy_traits_tests.cpp", line 155: error: static assertion failed
  static_assert(sizeof(pro::proxy<TrivialFacade>) == 2 * sizeof(void*));  // VTABLE should be eliminated, but a placeholder is required
  ^

"/proxy/tests/proxy_traits_tests.cpp", line 286: error: static assertion failed
  static_assert(!pro::facade<BadFacade_BadConstraints_NotConstant>);
  ^

3. Lastly, some diagnostic warnings may need to be supressed. As some unreferenced functions that were declared but never used are preventing the code to compile.

Anything I can do/help/test to address the static assertion issues?

Best,

[mingxwa]

@pedronahum Thank you for your feedback! I spent some time to investigate and filed #182 to make proxy compile for NVHPC. Could you help verify if it unblocks your work?

[pedronahum]

Hi @mingxwa,

Amazing! Managed to compile and run all the tests. Also checked several samples (what is printed vs what is expected) and all looks good.

Greatly appreciate your help!

[mingxwa]

@pedronahum FYI, we have added a pipeline to ensure proxy always compiles with NVHPC in the future. Thank you again for the feedback!

[pedronahum]

@mingxwa fyi, HPC SDK do not support virtual function calls on GPUs in C++ parallel algorithms. However, CPU acceleration works pretty well with Proxy. Happy to provide more info if of interest.

Best,

Pedro N.

[mingxwa]

Hi @pedronahum, thanks for the extra info! Could you share more details about the GPU constraints you’re seeing with HPC SDK and how they affect virtual function calls? Some examples or snippets would be really helpful.

[pedronahum]

Hi @mingxwa,

Sure, below please find a simple example (and Makefile) intended to demonstrate how ISO C++ & Proxy could be used to write code parallel code that is portable to CPUs and GPUs. The CPU and GPU code will compile, no warnings. GPU program, however, will crash with an illegal memory access error.

Makefile is also posted below, assumes proxy.h is in the same folder as the main.cpp file. Same code, two executables (./monte_carlo and ./monte_carlo_gpu).

The main issue seems to be std::execution::par_unseq and the HPC sdk document suggests "any user-provided code must not introduce data races or deadlocks if multiple calls are interleaved on the same thread, which is what happens when a loop is vectorized."

Moving to std::execution::par, however, fixes the issue.

Best,

#include <iostream>
#include <cmath>
#include <chrono>
#include <execution> // Required for execution policies
#include <random>
#include <span>
#include "proxy.h"

using namespace std;

// Define dispatch for Payout function
PRO_DEF_MEM_DISPATCH(MemPayOff, Payout);

// Define PayOff interface using proxy (with Payout function depending only on Spot)
struct PayOff : pro::facade_builder
    ::add_convention<MemPayOff, double(double) const>  // Only one argument: Spot
    ::support_copy<pro::constraint_level::nontrivial>
    ::build {};

// PayOffCall class (with Payout method for call option payoff)
struct PayOffCall {
public:
    PayOffCall(double Strike_) : Strike(Strike_) {}

    // Function for calculating the call option payoff based only on Spot
    double Payout(double Spot) const {
        return std::max(Spot - Strike, 0.0);  // Call option payoff logic
    }

private:
    const double Strike;  // Store Strike as part of the class
};

// Double Digital Payoff class (with lower and upper barriers)
struct PayOffDoubleDigital {
public:
    PayOffDoubleDigital(double lowerLevel, double upperLevel)
        : LowerLevel(lowerLevel), UpperLevel(upperLevel) {}

    // Function for calculating the double digital payoff based only on Spot
    double Payout(double Spot) const {
        if (Spot > LowerLevel && Spot < UpperLevel) {
            return 1.0;  // Pay 1 if Spot is between the barriers
        } else {
            return 0.0;  // Pay 0 otherwise
        }
    }

private:
    const double LowerLevel;
    const double UpperLevel;
};

// Monte Carlo simulation function with proxy for PayOff
double SimpleMonteCarlo1(double Expiry,
                         pro::proxy<PayOff> p,
                         double Spot,
                         double Vol,
                         double r,
                         unsigned long NumberOfPath)
{
    double variance = Vol * Vol * Expiry;
    double rootVariance = sqrt(variance);
    double itoCorrection = -0.5 * variance;
    double movedSpot = Spot * exp(r * Expiry + itoCorrection);

    // Create a vector to hold Gaussian random numbers for each path
    std::vector<double> gaussians(NumberOfPath);

    // Generate Gaussian random numbers
    std::random_device rd{};
    std::mt19937 generator(rd());
    std::normal_distribution<double> distribution(0.0, 1.0);

    std::generate(gaussians.begin(), gaussians.end(), [&]() {
        return distribution(generator);
    });

    printf("Generated %lu Gaussian numbers\n", gaussians.size());

    // Use std::transform_reduce with parallel execution for payoff calculations
    double runningSum = std::transform_reduce(
        std::execution::par_unseq,               // Execution policy
        gaussians.begin(), gaussians.end(),      // Input range (Gaussian numbers)
        0.0,                                     // Initial value for the sum
        std::plus<double>(),                     // Reduction function to sum payoffs
        [=](double thisGaussian) {               // Transform function to compute payoff
            double thisSpot = movedSpot * exp(rootVariance * thisGaussian);
            double thisPayoff = p->Payout(thisSpot);  // Using the proxy for payoff calculation
            return std::max(thisPayoff, 0.0);    // Return positive payoff or 0
        }
    );

    // Calculate the mean and discount it to present value
    double mean = runningSum / NumberOfPath;
    mean *= exp(-r * Expiry);

    return mean;
}


int main(int argc, char **argv) {
    // Start logs
    printf("[%s] - Starting...\n", argv[0]);

    // Parameters for the Monte Carlo simulation
    double Expiry = 1.0;
    double Strike = 100;
    double Spot = 100;
    double Vol = 0.2;
    double r = 0.05;
    unsigned long NumberOfPaths = 1'000'000;

    // Lower and upper barrier levels for Double Digital Payoff
    double lowerLevel = 90;
    double upperLevel = 110;

    // Create proxy for PayOffDoubleDigital (Double Digital Payoff)
    pro::proxy<PayOff> doubleDigitalPayoff = pro::make_proxy<PayOff, PayOffDoubleDigital>(lowerLevel, upperLevel);
    pro::proxy<PayOff> callPayoff = pro::make_proxy<PayOff, PayOffCall>(Strike);

    // Start the timer
    auto rt1 = std::chrono::high_resolution_clock::now();

    // Run the Monte Carlo simulation (now using Double Digital Payoff)
    double result = SimpleMonteCarlo1(Expiry, doubleDigitalPayoff, Spot, Vol, r, NumberOfPaths);

    // Stop the timer
    auto rt2 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> rtime_ms = (rt2 - rt1);
    double rtime = rtime_ms.count();

    // Output the results
    cout << "The Double Digital Payoff price is " << result << "\n";
    printf("SimpleMonteCarlo1 time : %f msec\n", rtime);

    // Start the timer
    rt1 = std::chrono::high_resolution_clock::now();

    // Run the Monte Carlo simulation (now using Call Payoff)
    result = SimpleMonteCarlo1(Expiry, callPayoff, Spot, Vol, r, NumberOfPaths);

    // Stop the timer
    rt2 = std::chrono::high_resolution_clock::now();

    rtime_ms = (rt2 - rt1);
    rtime = rtime_ms.count();

    // Output the results
    cout << "The Call Option price is " << result << "\n";
    printf("SimpleMonteCarlo1 time : %f msec\n", rtime);

    return 0;
}

Makefile below:

# Compiler
CXX = nvc++

# C++ Compiler flags
CXXFLAGS = -fast -mp -std=c++20

# Compiler flags, applicable for CPU
STDPARFLAGS_CPU = -stdpar=multicore -I.

# Compiler flags, applicable for GPU
STDPARFLAGS_GPU = -mp -stdpar=gpu -Wall -Wextra -Wpedantic -gpu=ccall -I.

# Target executables
TARGET_CPU = monte_carlo

# Target executables
TARGET_GPU = monte_carlo_gpu

# Source files
SOURCES = main.cpp

# Object files for CPU and GPU
OBJECTS_CPU = $(SOURCES:.cpp=_cpu.o)

# Object files for CPU and GPU
OBJECTS_GPU = $(SOURCES:.cpp=_gpu.o)

# Default rule (builds CPU version by default)
all: $(TARGET_CPU) $(TARGET_GPU)

# Build CPU version
$(TARGET_CPU): $(OBJECTS_CPU)
	$(CXX) $(CXXFLAGS) $(STDPARFLAGS_CPU) -o $@ $(OBJECTS_CPU)

# Build GPU version
$(TARGET_GPU): $(OBJECTS_GPU)
	$(CXX) $(CXXFLAGS) $(STDPARFLAGS_GPU) -o $@ $(OBJECTS_GPU)

# Compilation rule for CPU objects
%_cpu.o: %.cpp
	$(CXX) $(CXXFLAGS) $(STDPARFLAGS_CPU) -c $< -o $@

# Compilation rule for CPU objects
%_gpu.o: %.cpp
	$(CXX) $(CXXFLAGS) $(STDPARFLAGS_GPU) -c $< -o $@

# Clean up
clean:
	rm -f $(OBJECTS_CPU) $(OBJECTS_GPU) $(TARGET_CPU) $(TARGET_GPU)