OPENMP 串行版本的代码比并行版本快 我该如何解决

Question

here's a program that does some calculation and i am trying to use threads to make it run faster but i cannot make it run faster than the serial version.

serial output is

Function: y(x) = sin(x) [note that x is in radians]
Limits of integration: x1 = 7.000000, x2 = 2.000000 
Riemann sum with 5000 steps, a.k.a. dx=-0.001000 
Computed integral: 1.170175 
Exact integral:    1.170049 
Percent error:     0.010774 % 
Work took 0.182533 milliseconds

parallel output is

Function: y(x) = sin(x) [note that x is in radians]
Limits of integration: x1 = 7.000000, x2 = 2.000000 
Riemann sum with 5000 steps, a.k.a. dx=-0.001000 
Computed integral: 1.170175 
Exact integral:    1.170049 
Percent error:     0.010774 % 
Work took 0.667334 milliseconds

Here's the code

#include <stddef.h>  // for size_t
#include <stdio.h>
#include <stdlib.h>     /* atoi, atof */
#include <math.h>
#include "omp.h" // just used for timing

int main(int argc, char *argv[]) {
   double start, end;
   start = omp_get_wtime(); // Start our work timer

   // BEGIN TIMED CODE BLOCK
   double x, y;
   double x1, x2; // Limits of integration
   double dx;
   double ysum, integral;
   size_t i;
   size_t nsteps;

   // Read in command line arguments
   x1 = atof(argv[1]); // lower x limit
   x2 = atof(argv[2]); // upper x limit
   nsteps = atof(argv[3]); // number of steps in Riemann sum
  omp_set_num_threads(2); 
   // Compute delta x
      dx = (x2 - x1)/nsteps; // delta x for the Riemann sum

        // Perform numeric integration via Riemann sum
    ysum = 0;
        // Temporary variable to hold the sum prior to multiplication by dx
    #pragma omp parallel shared(ysum) private(x,y)
    {
        #pragma omp for 
        for (i=0; i<nsteps; i++) {
                x = x1 + i*dx; // x value at this step
                y = sin(x); // y(x) at this step; note that x is always in radians
            #pragma omp critical
            ysum += y; // summation of y(x)
        }               
    #pragma omp critical
    integral = ysum * dx; // Our computed integral: the summation of y(x)*dx
       // END TIMED CODE BLOCK
    }


   end = omp_get_wtime(); // Stop our work timer

   double analytic = -cos(x2) + cos(x1); // The known, exact answer to this integration problem

   printf("Function: y(x) = sin(x) [note that x is in radians]\n");
   printf("Limits of integration: x1 = %lf, x2 = %lf \n", x1, x2);
   printf("Riemann sum with %ld steps, a.k.a. dx=%lf \n", nsteps, dx); 
   printf("Computed integral: %lf \n", integral);
   printf("Exact integral:    %lf \n", analytic);
   printf("Percent error:     %lf %% \n", fabs((integral - analytic) / analytic)*100);
   printf("Work took %f milliseconds\n", 1000 * (end - start));
   return 0;
}

the output changes when i removed the critical sections so i assume i did the right thing there

Answer 1

Every time you have #pragma omp critical you impose a barrier to effective multithreading. You can use the #pragma omp parallel for directive, along with a reduction clause, to parallelize your loop.

#pragma omp parallel for reduction(+:ysum)
for (int i = 0; i < nsteps; ++i) {
    auto x = x1 + i * dx;
    auto y = sin(x);
    ysum += y;
}

integral = ysum * dx;

The temporary variables that are used within the loop are declared there, so that each thread will have its own copy of them (the loop body can be rewritten to not need x or y ). The reduce clause will (in this instance) keep a separate ysum value with each thread, then at the end add all those values together.