Black-Scholes Sample

The Black-Scholes Equation estimates the price of a European option over time. The formula itself can be used in a number of ways, the most basic of which is to use the projected value to smartly hedge the option on its underlying asset. The simulation in this sample is auto-vectorized with the Intel® C++ compiler and parallelized with OpenMP* Worksharing construct #pragma omp for .

System Requirements:

Hardware:
- Any Intel processor with Intel® Advanced Vector Extensions (Intel® AVX) support like 2nd Generation Intel® Core™ i3, i5, or i7 processors and Intel® Xeon® E3 or E5 processor family, or newer
For Microsoft* Windows*:
- Microsoft Visual Studio 2013* or above
- Intel® Parallel Studio XE 2018 Composer Edition for Windows or above
For Linux*:
- GNU* GCC 4.5 or newer
- Intel® Parallel Studio XE 2018 Composer Edition for Linux or above

Code Change Highlights:

#pragma omp for

linear version: (black_scholes.cpp, black_scholes_serial())

    for(int option = 0; option<OPT_N; ++option) {
        float T = OptionYears[option];
        float X = OptionStrike[option];
        float S = StockPrice[option];
        float sqrtT = sqrtf(T);
        float d1 = (logf(S / X) + (c_riskfree + c_half * c_volatility * c_volatility) * T) /
                   (c_volatility * sqrtT);
        float d2 = d1 - c_volatility * sqrtT;
#ifdef _WIN32
        float CNDD1 = CND(d1);
        float CNDD2 = CND(d2);
#else			
        float CNDD1 = c_half + c_half*erff(SQRT1_2*d1);
        float CNDD2 = c_half + c_half*erff(SQRT1_2*d2);
#endif
        float expRT = expf(-c_riskfree * T);

        CallResult[option] = S * CNDD1 - X * expRT * CNDD2;
        PutResult[option] = CallResult[option]  +  expRT - S;
    }

#pragma omp for version: (black_scholes.cpp, black_scholes_openmp())

#pragma omp parallel for
    for(int option = 0; option<OPT_N; ++option) {
        float T = OptionYears[option];
        float X = OptionStrike[option];
        float S = StockPrice[option];
        float sqrtT = sqrtf(T);
        float d1 = (logf(S / X) + (c_riskfree + c_half * c_volatility * c_volatility) * T) /
                   (c_volatility * sqrtT);
        float d2 = d1 - c_volatility * sqrtT;
#ifdef _WIN32
        float CNDD1 = CND(d1);
        float CNDD2 = CND(d2);
#else			
        float CNDD1 = c_half + c_half*erff(SQRT1_2*d1);
        float CNDD2 = c_half + c_half*erff(SQRT1_2*d2);
#endif
        float expRT = expf(-c_riskfree * T);

        CallResult[option] = S * CNDD1 - X * expRT * CNDD2;
        PutResult[option] = CallResult[option]  +  expRT - S;
    }

Performance Data:

Note: Modified Speedup shows performance speedup with respect to serial implementation.

Build Instructions:

For Visual Studio users:

Open the solution .sln file
[Optional] To collect performance numbers (will run example 5 times and take average time):
- Project Properties -> C/C++ -> Preprocessor -> Preprocessor Definitions: add PERF_NUM
Choose a configuration (for best performance, choose a release configuration):
- Intel-debug and Intel-release: uses Intel C++ compiler
- VSC-debug and VSC-release: uses Visual C++ compiler (only linear/scalar will run)

For Windows Command Line users:

Enable your particular compiler environment
for Intel C++ Compiler:
- open the appropriate Intel C++ compiler command prompt
- navigate to project folder
- compile with Build.bat [perf_num]
  - perf_num: collect performance numbers (will run example 5 times and take average time)
- to run: Build.bat run [help|0|1|2|3|4]
for Visual C++ Compiler (only linear/scalar will run):
- open the appropriate Visual Studio command prompt
- navigate to project folder
- to compile: Build.bat [perf_num]
  - perf_num: collect performance numbers (will run example 5 times and take average time)
- to run: Build.bat run

For Linux*/OS X* users:

set the icc environment: source <icc-install-dir>/bin/compilervars.sh {ia32|intel64}
navigate to project folder
for Intel C++ compiler:
- to compile: make [icpc] [perf_num=1]
  - perf_num=1: collect performance numbers (will run example 5 times and take average time)
- to run: make run [option=help|0|1|2|3|4]
for gcc (only linear/scalar will run):
- compile with make gcc [perf_num=1]
  - perf_num=1: collect performance numbers (will run example 5 times and take average time)
- to run: make run