带有加速功能的示例openmp程序

Question

Could someone provide an OpenMP program where the speedup is visible compared to without it. I'm finding it extremely difficult to achieve speedup. Even this simple program runs slower with OpenMP. My processor is Intel® Core™ i3-2370M CPU @ 2.40GHz × 4 running on Linux (Ubuntu 14.10)

#include <cmath>
#include <stdio.h>
#include <time.h> 
int main() {
   clock_t t;
   t = clock();
   const int size = 4;
   long long int k;

    #pragma omp parallel for num_threads(4)
    for(int n=0; n<size; ++n) {
       for(int j=0;j<100000000;j++){ 
       }
       printf("\n");
    }

    t = clock() - t;
    printf ("It took me %d clicks (%f seconds).\n",t,((float)t)/CLOCKS_PER_SEC);

    return 0;
}

Answer 1

Calculating a integral is a classical one, adjust the parts constant to increase the execution time and see more clearly the runtime, more parts, more execution time. It's getting 21.3 seconds with OpenMP enabled and 26.7 seconds, on a SINGLE core, DUAL thread Intel pentium 4:

#include <math.h>
#include <stdio.h>
#include <omp.h>

#define from 0.0f
#define to 2.0f
#define parts 999999999
#define step ((to - from) / parts)
#define x (from + (step / 2.0f))

int main()
{
        double integralSum = 0;
        int i;
        #pragma omp parallel for reduction(+:integralSum)
        for (i = 1; i < (parts+1); ++i)
        {
                integralSum = integralSum + (step * fabs(pow((x + (step * i)),2) + 4));
        }

        printf("%f\n", integralSum);

        return 0;
}

It calculates the definite integral from 0 to 2 of x^2 + 4

Answer 2

I had a problem related to this, where I wanted to find the max value of an array. I made the same mistake as you, I used clock for measuring the elapsed time. To fix this, I used clock_gettime() instead, and now it works.

As for an example code where the speedup is measurable (Note you migth want to change the value of N):

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

struct timespec diff(struct timespec start, struct timespec end)
{
struct timespec temp;

if(end.tv_sec - start.tv_sec == 0)
{
    temp.tv_nsec = end.tv_nsec - start.tv_nsec;
}
else
{
    temp.tv_nsec = ((end.tv_sec - start.tv_sec)*1000000000) + end.tv_nsec - start.tv_nsec;
}

return temp;
}

int main()
{
unsigned int N;
struct timespec t_start, t_end;
clock_t start, end;

srand(time(NULL));

FILE *f = fopen("out.txt", "w");
if(f == NULL)
{
    printf("Could not open output\n");
    return -1;
}

for(N = 1000000; N < 100000000; N += 1000000)
{
    fprintf(f, "%d\t", N);
    int* array = (int*)malloc(sizeof(int)*N);
    if(array == NULL)
    {
        printf("Not enough space\n");
        return -1;
    }
    for(unsigned int i = 0; i<N; i++) array[i] = rand();

    int max_val = 0.0;

    clock_gettime(CLOCK_MONOTONIC, &t_start);

    #pragma omp parallel for reduction(max:max_val)
    for(unsigned int i=0; i<N; i++)
    {
        if(array[i] > max_val) max_val = array[i];
    }

    clock_gettime(CLOCK_MONOTONIC, &t_end);

    fprintf(f, "%lf\t", (double)(diff(t_start, t_end).tv_nsec / 1000000000.0));

    max_val = 0.0;

    clock_gettime(CLOCK_MONOTONIC, &t_start);
    for(unsigned int i = 0; i<N; i++)
    {
        if(array[i] > max_val) max_val = array[i];
    }
    clock_gettime(CLOCK_MONOTONIC, &t_end);

    fprintf(f, "%lf\n", (double)(diff(t_start, t_end).tv_nsec / 1000000000.0));

    free(array);
}

fclose(f);

return 0;
}