1. /*
  2. Codes Here:
  3. // parallel code to generate prime numbers between 1 to N using openMP.//
  4. //Find prime numbers (serial Implementation)//
  5. //linear search//
  6. //dotProd//
  7. //Implement a parallel program to study the performance of the parallel for using OpenMP and compare the result with serial code
  8. //Write a simple OpenMP program to employ a ‘reduction’ clause to express the reduction of a for loop
  9. //Write an OpenMP program to specify that the schedule(dynamic, chunk-size) clause of the loop construct specifies that the for loop has the dynamic scheduling type.
  10. // MPI Program to perform binary search. //
  11. //Program to find biggest and smallest of three numbers in two different cores//
  12. //Program to perform matrix multiplication(omp prog)//
  13. //MPI program to find sum of an array//
  14. //. MPI program to find integration of function sin(X) over the range 0 to 2 pi MPI_Bcast to send information to each participating process and MPI_Reduce to get a grand total of the areas computed by each participating process.//
  15. //MPI program for matrix multiplication//
  16. */
  28. // parallel code to generate prime numbers between 1 to N using openMP.//
  30. #include<stdio.h>
  31. #include<omp.h>
  32. main()
  33. {
  34. int prime[1000],i,j,n;
  35. printf("\nIn order to find prime numbers from 1 to n, enter the value of n:");
  36. scanf("%d",&n);
  37. for(i=1;i<=n;i++)
  38. {
  39. prime[i]=1;
  40. }
  41. prime[1]=0;
  42. for(i=2;i*i<=n;i++)
  43. {
  44. /* multi-threading to remove multiples of prime number i from the list (array) */
  46. #pragma omp parallel for
  47. for(j=i*i;j<=n;j=j+i)
  48. {
  49. if(prime[j]==1)
  50. prime[j]=0;
  51. }
  53. }
  54. printf("\nPrime numbers from 1 to %d are\n",n);
  56. for(i=2;i<=n;i++)
  57. {
  58. if(prime[i] == 1)
  59. {
  60. printf("%d\t ",i);
  61. }
  62. }
  63. printf("\n");
  64. }
  77. //Find prime numbers (serial Implementation)//
  78. #include<stdio.h>
  79. #include<time.h>
  80. #include<unistd.h>
  82. int main(){
  83. double time_spent;
  84. clock_t begin=clock();
  86. int num,i,count,n;
  87. printf("Enter max range: ");
  88. scanf("%d",&n);
  90. for(num = 1;num<=n;num++){
  91. count = 0;
  93. for(i=2;i<=num/2;i++){
  94. if(num%i==0){
  95. count++;
  96. break;
  97. }
  98. }
  99. if(count==0 && num!= 1)
  100. printf("%d \t", num);
  101. }
  102. printf("\n");
  103. clock_t end = clock();
  104. time_spent = (double)(end-begin)/CLOCKS_PER_SEC;
  105. printf("\nTime elapsed: %f ", time_spent);
  106. return 0;
  107. }
  124. //linear search//
  125. #include<stdio.h>
  126. #include<omp.h>
  127. #define MAXTHREADS 10
  128. #define ARRAYSIZE 44
  129. int main(void)
  130. {
  131. int a[]={3,5,1,2,34,67,90,43,53,3,4,26,34,35,54,67,87,21,34,56,33,45,12,34,5,6,7,8,123,45,32,455,666,444,333,222,11,22,44,55,333,222},i,j,found=0,key=222;
  132. double start_time,run_time;
  133. for(j=1;j<=5;j++)
  134. {
  135. omp_set_num_threads(j);
  136. found=0;
  137. start_time = omp_get_wtime();
  138. #pragma omp parallel private(i)
  139. {
  141. int start,noofsteps;
  142. #pragma omp single
  143. printf("num of threads in action: %d\n",j);
  145. if(found==0)
  146. {
  148. start=(omp_get_thread_num())*(ARRAYSIZE/omp_get_num_threads());
  149. noofsteps=start+(ARRAYSIZE/omp_get_num_threads());
  150. if(ARRAYSIZE%j!=0)
  151. noofsteps+=(ARRAYSIZE%j);
  152. for(i=start;i<noofsteps;i++)
  153. if(key==a[i]) {
  154. printf("Key has been found in %d thread at %d position\n",omp_get_thread_num(),i+1);
  155. found=1;
  156. break;
  157. }
  159. }
  160. }
  161. run_time = omp_get_wtime() - start_time;
  162. printf("\n %f seconds %d threads \n ",run_time,j);
  163. }
  165. return 0;
  166. }
  180. //dotProd//
  181. #include <stdio.h>
  182. #include <stdlib.h>
  183. #include <time.h>
  184. #include <omp.h>
  186. #define VECTOR_LENGHT 1000
  188. double dot_product (int N, double* A, double* B)
  189. {
  190. double dot=0.0, *a,*b;
  191. int n,i, nthreads, tid;
  193. #pragma omp parallel default (none) reduction (+: dot)
  194. shared (N,A,B) private (n,i, nthreads, tid, a,b)
  195. {
  196. nthreads = omp_get_num_threads();
  197. tid = omp_get_thread_num();
  199. n = N/nthreads; // Min iter for all threads
  200. a = A + n*tid; // Ptrs to this threads
  201. b = B + n*tid; // chunks of X & Y
  203. if ( tid == nthreads-1 )
  204. n += N-n*nthreads;
  206. dot = a[0]*b[0];
  207. for (i=1; i<n; i++)
  208. dot += a[i]*b[i];
  209. }
  210. return dot;
  211. }
  213. int main (int argc, char *argv[])
  214. {
  215. int i;
  216. double vec_A[VECTOR_LENGHT], vec_B[VECTOR_LENGHT], sum;
  218. for (i=0; i<VECTOR_LENGHT; i++)
  219. vec_A[i] = vec_B[i] = 1.0*i;
  221. sum = dot_product(VECTOR_LENGHT, vec_A, vec_B);
  222. printf("Sum value: %.8f.\n", sum);
  224. system("PAUSE");
  225. return 0;
  226. }
  236. //Implement a parallel program to study the performance of the parallel for using OpenMP and compare the result with serial code
  237. //serialll
  238. Code Screenshot:
  242. #include<stdio.h>
  244. #include<time.h>
  246. #include<unistd.h>
  250. int main(){
  252. double time_spent;
  254. clock_t begin=clock()s;
  258. int num,i,count,n;
  260. printf("Enter max range: ");
  262. scanf("%d",&n);
  266. for(num = 1;num<=n;num++){
  268. count = 0;
  272. for(i=2;i<=num/2;i++){
  274. if(num%i==0){
  276. count++;
  278. break;
  280. }
  282. }
  284. if(count==0 && num!= 1)
  286. printf("%d \t", num);
  288. }
  290. printf("\n");
  292. clock_t end = clock();
  294. time_spent = (double)(end-begin)/CLOCKS_PER_SEC; printf("\nTime elapsed: %f ", time_spent); return 0;
  296. }
  298. //parallel
  300. #include<stdio.h>
  302. #include<omp.h>
  304. #include<time.h>
  306. #include<unistd.h>
  310. int main(){
  312. double time_spent;
  314. clock_t begin=clock();
  316. int prime[1000],i,j,n;
  318. printf("\nIn order to find prime numbers from 1 to n, enter the value of n:");
  320. scanf("%d",&n);
  322. for(i=1;i<=n;i++){
  324. prime[i]=1;
  326. }
  330. prime[1]=0;
  334. for(i=2;i*i<=n;i++){
  336. #pragma omp parallel for
  338. for(j=i*i;j<=n;j=j+i){
  340. if(prime[j]==1)
  342. prime[j]=0;
  344. }
  346. }
  348. printf("\nPrime numbers from 1 to %d are\n",n);
  350. for(i=2;i<=n;i++){
  352. if(prime[i] == 1){
  354. printf("%d\t ",i);
  356. }
  358. }
  360. printf("\n");
  362. clock_t end = clock();
  366. time_spent += (double)(end-begin)/CLOCKS_PER_SEC; printf("\nTime elapsed: %f ", time_spent);
  368. }
  380. //Write a simple OpenMP program to employ a ‘reduction’ clause to express the reduction of a for loop
  383. #include <stdio.h>
  384. #include <stdlib.h>
  385. #include <omp.h>
  386. void main()
  387. {
  388. int sum=0;
  389. int lsum=0;
  390. int A[8]={1,2,3,4,5,6,7,8};
  392. #pragma omp parallel private(lsum)
  393. {
  394. int i;
  395. #pragma omp for
  396. for (i=0; i<8; i++)
  397. {
  398. lsum = lsum +A[i];
  399. }
  400. #pragma omp critical
  401. {
  402. sum+=lsum;
  403. }
  404. }
  405. printf("sum is:%d\n", sum);
  407. }
  420. //Write an OpenMP program to specify that the schedule(dynamic, chunk-size) clause of the loop construct specifies that the for loop has the dynamic scheduling type.
  422. #include <omp.h>
  423. #include <stdio.h>
  424. #include <stdlib.h>
  425. #define CHUNKSIZE 10
  426. #define N 100
  428. int main (int argc, char *argv[])
  429. {
  430. int nthreads, tid, i, chunk;
  431. float a[N], b[N], c[N];
  432. for (i=0; i < N; i++)
  433. a[i] = b[i] = i * 1.0;
  434. chunk = CHUNKSIZE;
  436. #pragma omp parallel shared(a,b,c,nthreads,chunk) private(i,tid)
  437. {
  438. tid = omp_get_thread_num();
  439. if (tid == 0)
  440. {
  441. nthreads = omp_get_num_threads();
  442. printf("Number of threads = %d\n", nthreads);
  443. }
  444. printf("Thread %d starting...\n",tid);
  446. #pragma omp for schedule(dynamic,chunk)
  447. for (i=0; i<N; i++)
  448. {
  449. c[i] = a[i] + b[i];
  450. printf("Thread %d: c[%d]= %f\n",tid,i,c[i]);
  451. }
  453. }
  455. }
  468. // MPI Program to perform binary search. //
  469. #include<stdio.h>
  470. #include<time.h>
  471. #include<mpi.h>
  472. int main(int argc,char *argv[])
  473. {
  474. clock_t tic=clock();
  475. int rank, size;
  476. int a[10]={1,2,3,4,5,6,7,8,9,10};
  477. int b[10];
  478. int search=6,flag=0;
  479. int i;
  480. MPI_Init(&argc,&argv);
  481. MPI_Comm_rank(MPI_COMM_WORLD,&rank);
  482. MPI_Comm_size(MPI_COMM_WORLD,&size);
  483. MPI_Scatter(&a,5,MPI_INT,&b,5,MPI_INT,0,MPI_COMM_WORLD);
  484. if (rank==0)
  485. {
  486. for(i=0;i<5;i++)
  487. {
  488. if(b[i]==search)
  489. {
  490. printf("\nNumber Found!\t\t%d\t\t%d",rank,i);
  491. flag=1;
  492. }
  493. printf("\n%d\t\t%d",b[i],rank);
  494. }
  495. }
  496. if(rank==1)
  497. {
  498. for( i=0;i<5;i++)
  499. {
  500. if(b[i]==search)
  501. {
  502. printf("\nNumber Found!\t\t%d\t\t%d",rank,i);
  503. flag=1;
  504. }
  505. printf("\n%d\t\t%d",b[i],rank);
  506. }
  507. }
  521. //Program to find biggest and smallest of three numbers in two different cores//
  522. #include<stdio.h>
  523. #include<omp.h>
  524. #include<time.h>
  525. int main()
  526. {
  527. int a=50;
  528. int b=100;
  529. int c=150;
  530. clock_t start_clock = clock();
  531. #pragma omp parallel
  532. {
  533. int id = omp_get_thread_num();
  534. if(id==0)
  535. {
  536. if(a>b && a>c)
  537. printf("Biggest number is %d\n",a);
  538. else if(b>a && b>c)
  539. printf("Biggest number is %d\n",b);
  540. else
  541. printf("Biggest number is %d\n",c);
  542. }
  543. else
  544. {
  545. if(a<b && a<c)
  546. printf("Smallest number is %d\n",a);
  547. else if(b<a && b<c)
  548. printf("Smallest number is %d\n",b);
  549. else
  550. printf("Smallest number is %d\n",c);
  551. }
  552. }
  553. clock_t end_clock = clock();
  554. printf("\nProgram Execution Time : %ld ms\n\n",(end_clock-start_clock));
  555. return 0;
  556. }
  569. //Program to perform matrix multiplication(omp prog)//
  570. #include<stdio.h>
  571. #include<omp.h>
  572. #include<time.h>
  573. int main()
  574. {
  575. int i=0,j=0,k=0;
  576. int a[2][2]={{1,2},{3,4}};
  577. int b[2][2]={{1,2},{3,4}};
  578. int c[2][2]={{0,0},{0,0}};
  579. clock_t start_clock = clock();
  580. #pragma omp parallel for
  581. for(i=0;i<2;i++)
  582. {
  583. for(j=0;j<2;j++)
  584. {
  585. for(k=0;k<2;k++)
  586. {
  587. c[i][j]=c[i][j]+a[i][k]*b[k][j];
  588. }
  589. }
  590. }
  591. clock_t end_clock = clock();
  592. printf("\nProgram Execution Time : %ld ms\n\n",(end_clock-start_clock));
  593. printf("Resultant Matrix\n");
  594. for(i=0;i<2;i++)
  595. {
  596. for(j=0;j<2;j++)
  597. {
  598. printf("C[%d][%d]=%d\n",i,j,c[i][j]);
  599. }
  600. }
  602. return 0;
  603. }
  611. //MPI program to find sum of an array//
  615. #include "mpi.h"
  616. #include <stdio.h>
  617. #include <stdlib.h>
  618. #define ARRAYSIZE 20000000
  619. #define MASTER 0 double data[ARRAYSIZE];
  620. int main (int argc, char *argv[])
  621. {
  622. int numtasks, taskid, rc, dest, offset, i, j, tag1, tag2, source, chunksize, leftover;
  623. double mysum, sum;
  624. double update(int myoffset, int chunk, int myid); MPI_Status status;
  625. /***** Initializations *****/
  626. MPI_Init(&argc, &argv);
  627. MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
  628. MPI_Comm_rank(MPI_COMM_WORLD,&taskid); printf ("MPI task %d has started... ", taskid); chunksize = (ARRAYSIZE / numtasks); leftover = (ARRAYSIZE % numtasks); tag2 = 1; tag1 = 2;
  629. /***** Master task only ******/ if (taskid == MASTER){
  630. /* Initialize the array */
  631. sum = 0;
  632. for(i=0; i<ARRAYSIZE; i++) { data[i] = i * 1.0; sum = sum + data[i];
  633. }
  634. printf("Initialized array sum = %e\n",sum); printf("numtasks= %d chunksize= %d leftover= %d\ n",numtasks,chunksize,leftover);
  635. /* Send each task its portion of the array - master keeps 1st part plus
  636. leftover elements */ offset = chunksize + leftover; for (dest=1; dest<numtasks; dest++) {
  637. MPI_Send(&offset, 1, MPI_INT, dest, tag1, MPI_COMM_WORLD);
  638. MPI_Send(&data[offset], chunksize, MPI_DOUBLE, dest, tag2, MPI_COMM_WORLD); printf("Sent %d elements to task %d offset= %d\n",chunksize,dest,offset);
  639. offset = offset + chunksize; }
  640. /* Master does its part of the work */
  641. offset = 0;
  642. mysum = update(offset, chunksize+leftover, taskid);
  643. /* Wait to receive results from each task */
  644. for (i=1; i<numtasks; i++) { source = i;
  645. MPI_Recv(&offset, 1, MPI_INT, source, tag1, MPI_COMM_WORLD, &status);
  646. MPI_Recv(&data[offset], chunksize, MPI_DOUBLE, source, tag2,
  647. MPI_COMM_WORLD, &status);
  648. }
  649. /* Get final sum and print sample results */
  650. MPI_Reduce(&mysum, &sum, 1, MPI_DOUBLE, MPI_SUM, MASTER, MPI_COMM_WORLD);
  651. printf("Sample results: \n");
  652. offset = 0;
  653. for (i=0; i<numtasks; i++) { for (j=0; j<5; j++) printf(" %e",data[offset+j]);
  654. printf("\n");
  655. offset = offset + chunksize;
  656. }
  657. printf("*** Final sum= %e ***\n",sum); } /* end of master section */
  658. /***** Non-master tasks only *****/ if (taskid > MASTER) {
  659. /* Receive my portion of array from the master task */
  660. source = MASTER;
  661. MPI_Recv(&offset, 1, MPI_INT, source, tag1, MPI_COMM_WORLD, &status);
  662. MPI_Recv(&data[offset], chunksize, MPI_DOUBLE, source, tag2,
  663. MPI_COMM_WORLD, &status);
  664. /* Do my part of the work */
  665. mysum = update(offset, chunksize, taskid);
  666. /* Send my results back to the master task */ dest = MASTER;
  667. MPI_Send(&offset, 1, MPI_INT, dest, tag1, MPI_COMM_WORLD);
  668. MPI_Send(&data[offset], chunksize, MPI_DOUBLE, MASTER, tag2, MPI_COMM_WORLD);
  669. /* Use sum reduction operation to obtain final sum */
  670. MPI_Reduce(&mysum, &sum, 1, MPI_DOUBLE, MPI_SUM, MASTER, MPI_COMM_WORLD); } /* end of non-master */
  671. MPI_Finalize(); } /* end of main */
  672. double update(int myoffset, int chunk, int myid) { int i; double mysum;
  673. /* Perform addition to each of my array elements and keep my sum */
  674. mysum = 0;
  675. for(i=myoffset; i < myoffset + chunk; i++) {
  676. data[i] = data[i] + (i * 1.0); mysum = mysum + data[i];
  677. }
  678. printf("Task %d mysum = %e\n",myid,mysum);
  679. return(mysum);
  680. }
  682. //MPI program for matrix multiplication//
  684. #include "mpi.h"
  685. #include <stdio.h>
  686. #include <stdlib.h>
  687. #define NRA 62 /* number of rows in matrix A */
  688. #define NCA 15 /* number of columns in matrix A */
  689. #define NCB 7 /* number of columns in matrix B */
  690. #define MASTER 0 /* taskid of first task */
  691. #define FROM_MASTER 1 /* setting a message type */ #define FROM_WORKER 2 /* setting a message type */
  692. int main (int argc, char *argv[])
  693. {
  694. int numtasks, /* number of tasks in partition */
  695. taskid, /* a task identifier */ numworkers, /* number of worker tasks */ source, /* task id of message source */ dest, /* task id of message destination */ mtype, /* message type */
  696. rows, /* rows of matrix A sent to each worker */ averow, extra, offset, /* used to determine rows sent to each worker */ i, j, k, rc; /* misc */
  697. double a[NRA][NCA], /* matrix A to be multiplied */ b[NCA][NCB], /* matrix B to be multiplied */ c[NRA][NCB]; /* result matrix C */ MPI_Status status;
  698. MPI_Init(&argc,&argv);
  699. MPI_Comm_rank(MPI_COMM_WORLD,&taskid); MPI_Comm_size(MPI_COMM_WORLD,&numtasks);
  700. if (numtasks < 2 ) {
  701. printf("Need at least two MPI tasks. Quitting...\n");
  702. MPI_Abort(MPI_COMM_WORLD, rc); exit(1);
  703. }
  704. numworkers = numtasks-1;
  705. /**************************** master task ************************************/ if (taskid == MASTER)
  706. {
  707. printf("mpi_mm has started with %d tasks.\n",numtasks); printf("Initializing arrays...\n"); for (i=0; i<NRA; i++) for (j=0; j<NCA; j++) a[i][j]= i+j;
  708. for (i=0; i<NCA; i++) for (j=0; j<NCB; j++) b[i][j]= i*j;
  709. /* Send matrix data to the worker tasks */ averow = NRA/numworkers; extra = NRA%numworkers;
  710. offset = 0;
  711. mtype = FROM_MASTER;
  712. for (dest=1; dest<=numworkers; dest++)
  713. {
  714. rows = (dest <= extra) ? averow+1 : averow;
  715. printf("Sending %d rows to task %d offset=%d\n",rows,dest,offset);
  716. MPI_Send(&offset, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
  717. MPI_Send(&rows, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
  718. MPI_Send(&a[offset][0], rows*NCA, MPI_DOUBLE, dest, mtype,
  719. MPI_COMM_WORLD);
  720. MPI_Send(&b, NCA*NCB, MPI_DOUBLE, dest, mtype, MPI_COMM_WORLD); offset = offset + rows; }
  721. /* Receive results from worker tasks */ mtype = FROM_WORKER;
  722. for (i=1; i<=numworkers; i++)
  723. { source = i;
  724. MPI_Recv(&offset, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
  725. MPI_Recv(&rows, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
  726. MPI_Recv(&c[offset][0], rows*NCB, MPI_DOUBLE, source, mtype, MPI_COMM_WORLD, &status); printf("Received results from task %d\n",source);
  727. }
  728. /* Print results */
  729. printf("******************************************************\n"); printf("Result Matrix:\n"); for (i=0; i<NRA; i++)
  730. {
  731. printf("\n"); for (j=0; j<NCB; j++) printf("%6.2f ", c[i][j]);
  732. }
  733. printf("\n******************************************************\n"); printf ("Done.\n");
  734. }
  735. /**************************** worker task ************************************/ if (taskid > MASTER)
  736. {
  737. mtype = FROM_MASTER;
  738. MPI_Recv(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status);
  739. MPI_Recv(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status);
  740. MPI_Recv(&a, rows*NCA, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD,
  741. &status);
  742. MPI_Recv(&b, NCA*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD,
  743. &status);
  744. for (k=0; k<NCB; k++) for (i=0; i<rows; i++)
  745. {
  746. c[i][k] = 0.0; for (j=0; j<NCA; j++)
  747. c[i][k] = c[i][k] + a[i][j] * b[j][k];
  748. }
  749. mtype = FROM_WORKER;
  750. MPI_Send(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD);
  751. MPI_Send(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD);
  752. MPI_Send(&c, rows*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD);
  753. }
  754. MPI_Finalize(); }
  756. //. MPI program to find integration of function sin(X) over the range 0 to 2 pi MPI_Bcast to send information to each participating process and MPI_Reduce to get a grand total of the areas computed by each participating process.//
  759. #include <stdio.h>
  760. #include <math.h>
  761. #include <mpi.h> #define PI 3.1415926535
  762. main(int argc, char **argv)
  763. {
  764. int my_id, root_process, num_procs, ierr, num_intervals, i; double rect_width, area, sum, x_middle, partial_sum; MPI_Status status;
  765. /* Let process 0 be the root process. */
  767. root_process = 0; /* Now replicate this process to create parallel processes. */ ierr = MPI_Init(&argc, &argv); /* Find out MY process ID, and how many processes were started. */
  768. ierr = MPI_Comm_rank(MPI_COMM_WORLD, &my_id); ierr = MPI_Comm_size(MPI_COMM_WORLD, &num_procs); if(my_id == root_process) {
  769. /* I must be the root process, so I will query the user to determine how many interpolation intervals to use. */
  770. printf("Please enter the number of intervals to interpolate: "); scanf("%i", &num_intervals); }
  771. /* Then...no matter which process I am:
  772. *
  773. * I engage in a broadcast so that the number of intervals is * sent from the root process to the other processes, and ...
  774. **/
  775. ierr = MPI_Bcast(&num_intervals, 1, MPI_INT, root_process, MPI_COMM_WORLD); /* calculate the width of a rectangle, and */ rect_width = PI / num_intervals;
  776. /* then calculate the sum of the areas of the rectangles for
  777. * which I am responsible. Start with the (my_id +1)th * interval and process every num_procs-th interval thereafter.
  778. **/ partial_sum = 0;
  779. for(i = my_id + 1; i <num_intervals + 1; i += num_procs) {
  781. /* Find the middle of the interval on the X-axis. */
  782. x_middle = (i - 0.5) * rect_width; area = sin(x_middle) * rect_width; partial_sum = partial_sum + area;
  783. }
  784. printf("proc %i computes: %f\n", my_id, (float)partial_sum);
  785. /* and finally, engage in a reduction in which all partial sums
  786. * are combined, and the grand sum appears in variable "sum" in
  787. * the root process,
  788. **/
  789. ierr = MPI_Reduce(&partial_sum, &sum, 1, MPI_DOUBLE, MPI_SUM, root_process, MPI_COMM_WORLD); /* and, if I am the root process, print the result. */
  790. if(my_id == root_process) {
  791. printf("The integral is %f\n", (float)sum);
  792. /* (yes, we could have summed just the heights, and
  793. * postponed the multiplication by rect_width til now.) */
  794. } /* Close down this processes. */
  795. ierr = MPI_Finalize(); }