Witam.

Napisałem prosty program do oblicznaia silni, który uzywał 4 wątków do obliczeń:

 #include<omp.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
#include"my_timers.h"


unsigned long long int factorial( int number)
 {
   unsigned long long int fac = 1;
int n = 0;
   #pragma omp parallel for
   for(n=2; n<=number; ++n)
   {
     #pragma omp atomic
     fac *= n;
   }
   return fac;
 }

int main(int argc, char *argv[])
{
unsigned long long int wynik;
 int opcja; 
opcja = atoi(argv[1]);
printf("opcja = %d\n", opcja);
omp_set_num_threads(4);
start_time();
wynik = factorial(opcja);
printf("wynik = %llu\n", wynik);
stop_time();
print_time("Elapsed:");
}

Problem polega na tym, że nie widać przyspieszenia gdy pracuje na 4 wątkach porównując do konwencjonalnego programu liczenia silni. Ba, program jest wolniejszy. Normalnie dla 20! wykonuje sie 0 ms (4 wątki - ~10ms). Rozumiem, że to przez to, ze potrzeba czasu na zainicjalizowanie działania wątków. Więc pomyslałem, że przerobię trochę program w ten sposób, żeby liczył silnie dużych liczb:

 #include<stdio.h>
#include"my_timers.h"

int main(int argc, char *argv[])
{
    int t;
    int a[220000];
    int n,i,j,temp,m,x;
    n = atoi(argv[1]);

       a[0]=1;  
       m=1;    

       temp = 0; 
    start_time();
       for(i=1;i<=n;i++)
       {
            for(j=0;j<m;j++)
            {
               x = a[j]*i+temp; 
               a[j]=x%10; 
               temp = x/10;
            }
             while(temp>0) 
             { 
               a[m]=temp%10;
               temp = temp/10;
               m++; 
             }
      }
stop_time();
              for(i=m-1;i>=0;i--) 
              printf("%d",a[i]);
              printf("\n");
        print_time("Elapsed:");    
    return 0;
}

No i liczy (do 50000!) odpowiednio długo - na tyle aby mozna było porównać czasy pracy na 4 wątkach i na jednym. Niestety nie da się go zrównoleglić (albo ja nie wiem jak). Ktoś ma jakiś pomysl, jak napisac algorytm dla silni wielkich liczb w taki sposób aby dało się go jakoś w łatwy sposób zrównoleglać i pokazac wzrost szybkości w stosunku do rozwiązania konwencjonalnego?