Differences in OpenMP performance with different versions of OS - c

Question

I have a piece of code that i wrote a time ago. The only purpose of it was an experiment with openMP. But i recently switched form a MacBook Pro Lion (early 2011) to a MacBook Pro Mountain Lion (early 2013). If it would help to get more hardware of other info, I would be happy to give them.
The code worked fine on the old one, meaning 8 threads got a 100% (98% min) load on my processor. And now the identical code, recompiled on my new machine gets only a 62% max processor load. Even if I raise the threads. The processor loads are both measured with "istat pro".
My question is what can cause this to happen?
EDIT: The problem seems to be solved if I delete the for in #pragma omp parallel for shared(largest_factor, largest). So I get #pragma omp parallel shared(largest_factor, largest)
But I still don't understand why it works.
The code in question:
#include <stdio.h>
#include <omp.h>
double fib(double n);
int main()
{
int data[] = {124847,194747,194747,194747,194747,
194747,194747,194747,194747,194747,194747};
int largest, largest_factor = 0;
omp_set_num_threads(8);
/* "omp parallel for" turns the for loop multithreaded by making each thread
* iterating only a part of the loop variable, in this case i; variables declared
* as "shared" will be implicitly locked on access
*/
#pragma omp parallel for shared(largest_factor, largest)
for (int i = 0; i < 10; i++) {
int p, n = data[i];
for (p = 3; p * p <= n && n % p; p += 2);
printf("\n%f\n\n",fib(i+40));
if (p * p > n) p = n;
if (p > largest_factor) {
largest_factor = p;
largest = n;
printf("thread %d: found larger: %d of %d\n",
omp_get_thread_num(), p, n);
}
else
{
printf("thread %d: not larger: %d of %d\n",
omp_get_thread_num(), p, n);
}
}
printf("Largest factor: %d of %d\n", largest_factor, largest);
return 0;
}
double fib(double n)
{
if (n<=1)
{
return 1;
}
else
{
return fib(n-1)+fib(n-2);
}
}

Answer 1

The main reason you don't see all threads being used is that each thread takes different time (due to the recursive function or the inner loop) and you only have 10 iterations. The fast threads finish fast and then there are only a few threads left to run. When you first run your code it starts off 100% and falls off as the fast threads finish and the few last slow threads are still running. If you change your iterations to 100 (and increase the data array) you will see the CPU usage at 100% for much longer. I added some timing printouts to your code.
Also I think you have a race condition with your shared variables so I put in a critical section.
To answer your question about the code without the "for" statement what that's doing is running the same code on eight different threads! Instead of threads running a particular iteration they each run all 10 iterations. That's going to be no faster than running a single thread and perhaps even slower.
Lastly since each iteration takes different time in general you should use "schedual(dynamic)" like this
#pragma omp parallel for shared(largest_factor, largest) schedule(dynamic)
However, since you only have 10 iterations I don't think it will make much difference in this case. Here is what I did to your code to understand what is going on:
#include <stdio.h>
#include <omp.h>
double fib(double n);
int main()
{
int data[] = {124847,194747,194747,194747,194747,
194747,194747,194747,194747,194747,194747};
int largest, largest_factor = 0;
omp_set_num_threads(8);
/* "omp parallel for" turns the for loop multithreaded by making each thread
* iterating only a part of the loop variable, in this case i; variables declared
* as "shared" will be implicitly locked on access
*/
#pragma omp parallel for shared(largest_factor, largest)
for (int i = 0; i < 10; i++) {
int p, n = data[i];
double time = omp_get_wtime();
for (p = 3; p * p <= n && n % p; p += 2);
printf("\n iteratnion %d, fib %f\n\n",i, fib(i+40));
time = omp_get_wtime() - time;
printf("time %f\n", time);
if (p * p > n) p = n;
#pragma omp critical
{
if (p > largest_factor) {
largest_factor = p;
largest = n;
printf("thread %d: found larger: %d of %d\n",
omp_get_thread_num(), p, n);
}
else {
printf("thread %d: not larger: %d of %d\n",
omp_get_thread_num(), p, n);
}
}
}
printf("Largest factor: %d of %d\n", largest_factor, largest);
return 0;
}
double fib(double n) {
if (n<=1) {
return 1;
}
else {
return fib(n-1)+fib(n-2);
}
}