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?