Re: gomp slowness

[skaller <skaller at users dot sourceforge dot net>]

On Thu, 2007-10-18 at 12:02 +0800, Biplab Kumar Modak wrote:
> skaller wrote:
> > On Wed, 2007-10-17 at 18:14 +0100, Biagio Lucini wrote:
> >> skaller wrote:
> > 
> >> It would be interesting to try with another compiler. Do you have access 
> >> to another OpenMP-enabled compiler?
> > 
> > Unfortunately no, unless MSVC++ in VS2005 has openMP.
> > I have an Intel licence but they're too tied up with commerical
> > vendors and it doesn't work on Ubuntu (it's built for Fedora and Suse).
> > 
> If possible, you can post the source code. I've a MSVC 2005 license (I 
> bought it to get OpenMP working with it).
> 
> I can then give it a try. I have a dual core PC. :)

OK, attached.


-- 
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net

/*
 * LU.c
 * 
 * A prgram to d an LU decomposition.
 *
 */

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

#define SIZE 800

int main(int argc, char *argv[])
{
  double start, stop; /* for keeping track of running time */
  double A[SIZE][SIZE];
  double col[SIZE], row[SIZE];
  int i, j, k, n;

  /* preload A with random values */
  for (i = 0; i<SIZE; i++)
    for (j = 0; j<SIZE; j++)
      A[i][j] = rand();

  /* time start now */
  start = clock();

  /* The core algorithm */
  // #pragma omp parallel shared(A, col, row)
  for (k = 0; k<SIZE-1; k++) {
    /* set col values to column k of A */
    for (n = k; n<SIZE; n++) {
      col[n] = A[n][k];
    }

    /* scale values of A by multiplier */
    for (n = k+1; n<SIZE; n++) {
      A[k][n] /= col[k];
    }

    /* set row values to row k of A */
    for (n = k+1; n<SIZE; n++) {
      row[n] = A[k][n];
    }

    /* Here we update A by subtracting the appropriate values from row
       and column.  Note that these adjustments to A can be done in
       any order */
#pragma omp parallel for shared(A, row, col)
    for (i = k+1; i<SIZE; i++) {
      for (j = k+1; j<SIZE; j++) {
	A[i][j] = A[i][j] - row[i] * col[j];
      }
    }
  }

  /* we're done so stop the timer */
  stop = clock();

  printf("Completed decomposition in %.3f seconds\n", (stop-start)/CLOCKS_PER_SEC);

  

  return 0;
}



/*
 * combined.c
 *
 * This program combines what we saw before.  It calculates e and pi
 * and then integrates the x^2.  We also print out the elapsed time in
 * ms at several points in our program.  We have replaced the function y=x^2
 * with a more complex polynomial 3x^3 + 2x^2 + x.
 */

#include <stdio.h>
#include <time.h>

#define num_steps 10000000 /* steps to use in taylor expansions */
#define int_steps (1<<30)  /* steps to use in integration */

int main(int argc, char *argv[])
{
  double start, stop; /* times of beginning and end of procedure */

  /* Values for part 1 */
  double e, pi, factorial, product;
  int i;

  /* Values for part 2 */
  double sum;
  double x;

  /* start the timer */
  start = clock();

#pragma omp parallel reduction(+: sum)
  {
#pragma omp sections nowait
    {
#pragma omp section
      {
	/* First we calculate e from its taylor expansion */
	printf("e started at %.0f\n", clock()-start);
	e = 1;
	factorial = 1;
	for (i = 1; i<num_steps; i++) {
	  factorial *= i;
	  e += 1.0/factorial;
	}
	printf("e done at %.0f\n", clock()-start);
      }
#pragma omp section
      {
	/* Then we calculate pi from its taylor expansion */
	printf("pi started at %.0f\n", clock()-start);
	
	pi = 0;
	for (i = 0; i < num_steps*20; i++) {
	  pi += 1.0/(i*4.0 + 1.0);
	  pi -= 1.0/(i*4.0 + 3.0);
	}
	pi = pi * 4.0;
	printf("pi done at %.0f\n", clock()-start);
      }
    } /* sections */

    /* Now we integrate the function */
    printf("integration started at %.0f\n", clock()-start);
    sum = 0;
#pragma omp for nowait
    for (i = 0; i<int_steps; i++) {
      x = 2.0 * (double)i / (double)(int_steps); /* value of x */
      sum += ( 3*x*x*x + 2*x*x + x ) / int_steps;
    }

#pragma omp single /* we only need to print this once */
    printf("integration done at %.0f\n", clock()-start);


#pragma omp barrier
    /* make sure all threads are caught up before we do the multiplication */
    product = e * pi;
  
  } /* omp parallel */

  /* we're done so stop the timer */
  stop = clock();

  printf("Values: e*pi = %f,  integral = %f\n", product, sum);
  printf("Total elapsed time: %.3f seconds\n", (stop-start)/1000);

  return 0;
}