Parallelizing MC Integration with OpenMP problem: I need to evaluate how well my parallel version of the code performs for accuracy and timing. I chose n $=100,200,2000,32768$ and p$=1,2,6,7.$ Then use the result to answer questions like:How does varying the number of random points affect the accuracy, in general? $$ Does varying the number of threads affect the accuracy of the algorithm? If so$,$ describe in general how it does so$.$ Is your program scalable? If so$,$ is it strongly scalable or weakly scalable? Justify your answer with examples from your data. If you have a better version of code that would help solve the problem then please use it or you can use what I have:

$/*$ File: omp$\_$mc$\_$integration.cpp

$*$ Purpose: Use OpenMP to implement a parallel version of the Monte Carlo

$*$ method for estimating the integral of a function. This version

$*$ uses OpenMP's reduction clause to compute the global sum.

$*$

$*$ Input: The endpoints of the interval of integration and the number

$*$ of random points

$*$ Output: Estimate of the integral from a to b of f$($x$)$

$*$ using the Monte Carlo method and n random points.

$*$

$*$ Compile: g$++-$fopenmp omp$\_$mc$\_$integration.cpp $-$o mc$\_$int

$*$ Run: $./$mc$\_$int

$*$

$*$ Algorithm:

$*1.$ The total number of points $\text{'}$n$\text{'}$ is divided as evenly as possible among the threads.

$*2.$ Each thread applies the mc$\_$integration function to its local number of points,

$*$ which gives the count of points below the curve f$($x$).$

$*3.$ All local counts are summed up using OpenMP's reduction clause to get a global count.

$*4.$ The main thread performs the final calculation for the integral using the global count

$*$ and prints the result.

$*$

$*$ Note: f$($x$)$ is all hardwired.

$*/$

#include

#include

#include

#include

#include

using namespace std;

$/*$ Get the input values $*/$

void Get$\_$input$($long double$*$ a$\_$p$,$ long double$*$ b$\_$p$,$ long long$*$ n$\_$p$)$;

$/*$ Calculate count of points under the curve $*/$

long long mc$\_$integration$($long double a$,$ long double b$,$ long long local$\_$n$,$ long long my$\_$first$\_$i$,$ long long my$\_$last$\_$i$,$ int seed$)$;

$/*$ Function we're integrating $*/$

long double f$($long double x$)$;

int main$($int argc, char$*$ argv$[])\{$

int thread$\_$count;

long double lower$\_$bound, upper$\_$bound; $//$ Lower and upper bounds for y values in Monte Carlo method

long double est$\_$above$\_$lower$\_$bound, area$\_$under$\_$lower$\_$bound, total$\_$est; $//$ Estimates for areas

double start$\_$alg, finish$\_$alg; $//$ Start and finish times for main algorithm

double local$\_$elapsed, max$\_$elapsed; $//$ Elapsed times for each process and maximum elapsed time

if $($argc $>1)\{$

thread$\_$count $=$ std::atoi$($argv$[1])$; $//$ Assign the value to the original thread$\_$count

omp$\_$set$\_$num$\_$threads$($thread$\_$count$)$;

$\}$

$//$ Get input values from user

Get$\_$input$($&a$,$ &b$,$ &n$)$;

$//$ Calculate width of interval and bounds for y values

width $=$ b $-$ a;

lower$\_$bound $=$ f$($a$)/2$;

upper$\_$bound $=$ f$($b$)$;

$//$ Initialize the total count

c $=0$;

$//$ Start the timer

start$\_$alg $=$ omp$\_$get$\_$wtime$()$;

#pragma omp parallel num$\_$threads$($thread$\_$count$)$ reduction$(+$:c$)$

$\{$

$//$ Start the parallel region

int my$\_$rank $=$ omp$\_$get$\_$thread$\_$num$()$; $//$ Get the rank of the current thread

int size $=$ omp$\_$get$\_$num$\_$threads$()$; $//$ Get the total number of threads

$//$ Calculate number of points for each thread

int div $=$ n $/$ size;

int rem $=$ n $\%$ size;

long long my$\_$first$\_$i$,$ my$\_$last$\_$i$,$ local$\_$n;

$//$ Determine the range of points for each thread

if $($my$\_$rank $<$ rem$)\{$

$//$ If rank is less than remainder, thread gets n$/$p $+1$ points

my$\_$first$\_$i $=$ my$\_$rank $*($div $+1)$;

my$\_$last$\_$i $=$ my$\_$first$\_$i $+$ div;

local$\_$n $=$ my$\_$last$\_$i $-$ my$\_$first$\_$i;

$\}$ else $\{$

$//$ If rank is greater than or equal to remainder, thread gets n$/$p points

my$\_$first$\_$i $=$ my$\_$rank $*$ div $+$ rem;

my$\_$last$\_$i $=$ my$\_$first$\_$i $+$ div;

local$\_$n $=$ my$\_$last$\_$i $-$ my$\_$first$\_$i;

$\}$

$//$ Each thread performs Monte Carlo integration over its range of points

c $+=$ mc$\_$integration$($a$,$ b$,$ local$\_$n$,$ my$\_$first$\_$i$,$ my$\_$last$\_$i$,$ my$\_$rank$)$;

$\}$

$//$ Calculate elapsed time for main algorithm

finish$\_$alg $=$ omp$\_$get$\_$wtime$()$;

local$\_$elapsed $=$ finish$\_$alg $-$ start$\_$alg;

$//$ Calculate and print the final estimate

est$\_$above$\_$lower$\_$bound $=($static$\_$cast$($c$)/$ static$\_$cast$($n$))*($width $*($upper$\_$bound $-$ lower$\_$bound$))$;

area$\_$under$\_$lower$\_$bound $=$ width $*$ lower$\_$bound;

total$\_$est $=$ est$\_$above$\_$lower$\_$bound $+$ area$\_$under$\_$lower$\_$bound;

cout $<<$ "With n $="<<$ n $<<"$ points, our estimate" $<<$ endl;

cout $<<"$of the integral from $"<<$ a $<<"$ to $"<<$ b;

cout $<<$ setprecision$(15)$;

cout $<<"="<<$ total$\_$est $<<$ endl;

cout $<<$ "The algorithm for estimating the integral took $"<<$ local$\_$elapsed $<<"$ seconds to execute." $<<$ endl;

return