 # Answered! Write a parallel program pie.c in C or C++ (pie.cc) for Linux that computes an approximation of the number π using…

Write a parallel program pie.c in C or C++ (pie.cc) for Linux that computes an approximation of the number π using a series’ with N+1 terms. The series sum is partitioned in T non-overlapping partial sums, each computed by T separate child processes created with the fork() library function. This program demonstrates data parallelism and interprocess communication using pipes. Each child process could perform a (potentially) long computation on a separate CPU (or core), thus, the entire computation could reach a speedup close to T. Numbers N and T are passed from the shell to the pie program as command line parameters. The main(argc, argv[]) function call gets these parameters (T, N) in argv and argv as strings, respectively. (Element argv contains the program name and we don’t need it.)

The first parameter, N, is the upper limit for i in the formula above. The second parameter, T, is the
number of child processes that compute partial sums. N should always be greater than T, N>T.
Otherwise the program should display an error message and call exit(1).
Use the Nilakantha approximation formula for π (http://en.wikipedia.org/wiki/Pi):
π = 3 + 4/(2*3*4) – 4/(4*5*6) + 4/(6*7*8) – 4/(8*9*10) + …. + k*4/((2*i)* (2*i+1)*( 2*i+2))+…
where k = 1 if i is odd and k = -1 if i is even and i goes from 1 to N.
The program can be run like this from the shell:
./pie N T
For instance,
./pie 100 4
This command computes the approximation with 101 terms (starting with term 3) with 4 child
processes.
Here is a description of the algorithm to be implemented.
The parent process iterates with an index variable of type int called j from 0 to T (0≤j<T). During
iteration with index j, the parent process …
1. creates a pipe associated with child process with index j
2. creates a child process with fork()
3. writes the values N, T, and j to the pipe
After ending the loop (above) that created the T child processes, the parent process starts a new loop,
with index j from 0 to T (0≤j<T). In iteration with index j, the parent process reads from the pipe
associated with child j the value of the partial sum computed by the child and adds it to an accumulator
double variable.
After the second loop ends, the parent process:
1. displays the sum approximating the value of π stored in the accumulator, with a message that
2. The approximation of pi with N=%d and T=%d processes is %f.
(this is a C printf format string, make sure the code displays the actual numbers!)
3. waits for all child processes to end
4. exits with code 0.
The child process with index j runs its code in a function called computePartialSum.
In this function the child process does this:
1. closes any unnecessary file descriptors (which ones?)
2. reads values N,T, and j from the pipe, which were written by the parent process
3. computes the partial sum (as described below)
4. writes the partial sum to the pipe
5. calls exit(0).
NOTE: for this homework the child process should NOT rely on global variables to access N, T, and j.
These values must be read from the parent process using a pipe. Doing otherwise is considered a
mistake and points will be cut.
For example, if the user runs command
./pie 100 4
then :
child process #0 computes the partial sum for i going from 0 to 24
child process #1 computes the partial sum for i going from 25 to 49
child process #2 computes the partial sum for i going from 50 to 74
child process #3 computes the partial sum for i going from 75 to 99

Don't use plagiarized sources. Get Your Custom Essay on
Answered! Write a parallel program pie.c in C or C++ (pie.cc) for Linux that computes an approximation of the number π using…
GET AN ESSAY WRITTEN FOR YOU FROM AS LOW AS \$13/PAGE

```#include <iostream>

using namespace std;

int main()
{

int counter = 1;
double odd = 1;

double sum = 0;
int max = 10000;

bool bSign = true;

double pi = 0;
//4-(4/3)+(4/5)-(4/7)+(4/9)-(4/11)+...

do {
if(bSign)
{
pi += 4 / odd;
bSign = false;
}
else
{
pi -= 4 / odd;
bSign = true;
}
odd+=2;
counter++;
sum += pi;
cout << pi << endl;

} while ( counter < max );

cout << "PI : " << (sum / counter) << endl;
return 0;
}```