Pi Greco con OpenMP e GMP

Per testare il calcolo parallelo e l'Hyperthreading avevo la necessita' di un algoritmo parallelizzabile e con una convergenza piuttosto lenta per poter apprezzare le differenze di tempo di calcolo nella versione parallela e non parallela.

Scartato il calcolo di Pi Greco mediante la formula di Gauss (gia' utilizzata in un precedente post) perche' ricorsiva e quindi non parallelizzabile e scartato l'insieme di Mandelbrot perche' comunque un minimo complesso , ho provato a determinare il valore di Pi Greco mediante lo sviluppo in serie di Taylor mediante la formula

La sommatoria converge con estrema lentezza al valore di Pi Greco

Standard (tempo di esecuzione 0.049s)
-----------------------------------------------------

#include <cmath>
#include <iostream>

using namespace std;

int main()
{

float pi_s = 0.0;

for (int n=0; n<100000;++n)
{
pi_s = pi_s + (pow(-1,n)/(2*n+1));
}
cout << "Normale " << pi_s*4 << endl <<endl;

return 0;
}
-----------------------------------------------------


OMP (tempo di esecuzione 0.05s)
-----------------------------------------------------

#include <cmath>
#include <iostream>
#include <omp.h>

using namespace std;

int main()
{

float pi_s = 0.0;
#rpragma omp parallel
{
#pragma omp for reduction(+:pi_s) nowait
for (int n=0; n<100000;++n)
{
pi_s = pi_s + (pow(-1,n)/(2*n+1));
}
}
cout << "Normale " << pi_s*4 << endl <<endl;

return 0;
}

-----------------------------------------------------


GMP (tempo di esecuzione 0.1s)
-----------------------------------------------------

#include <cmath>
#include <iostream>
#include <gmp.h>

using namespace std;

int main()
{
mpf_t pi;
mpf_t transi;
mpf_t print;


int sopra;
int sotto;
//float pi_s = 0.0;

mpf_init_set_ui(pi,0);
mpf_init_set_ui(transi,1);
mpf_init_set_ui(print,0);

for (int n=0; n<100000000;++n)
{
sopra = pow(-1,n);
sotto = (2*n)+1;
mpf_set_si(transi,sopra);
mpf_div_ui(transi,transi,sotto);
mpf_add(pi,pi,transi);
mpf_mul_ui(print,pi,4);

//Calcolo eseguito senza GMP
//pi_s = pi_s + (pow(-1,n)/(2*n+1)); 
//cout << "Normale " << pi_s*4 << endl <<endl;
}
gmp_printf("Pi %.Ff\n",print);

return 0;
}



-----------------------------------------------------

L'integrazione di OMP e GMP non e' banale perche' se si uniscono i due esempi sopra riportati il compilatore riporta che la variabile pi has invalid type for ' reduction'

Hyperthreading e Open MP su Atom N450

Stavo pensando di iniziare a studiare la programmazione parallela quando mi sono accorto che tutte le mie macchine sono vecchiotte (ad esclusione del portatile di mia moglie che pero' e' intoccabile) e non sono provviste di un processore dual core. Avevo quasi abbandonato l'idea quando leggendo ho scoperto che il processore N450, pur essendo Single Core, possiede l'HyperThreading ovvero la capacita' di gestire piu' thread sul un solo core

Atom N450

Digitando il comando lscpu infatti si legge che

Architecture:  i686
CPU op-mode(s): 32-bit, 64-bit
CPU(s): 2
Thread(s) per core: 2
Core(s) per socket: 1
CPU socket(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 28
Stepping: 10
CPU MHz: 1662.438
L1d cache: 24K
L1i cache: 32K
L2 cache:  512K

Si vede chiaramente la presenza di un solo core ma i thread risultano due per cui e' possibile fare calcolo parallelo su N450

P4 640 3.2 GHz

Incuriosito mi sono chiesto se anche l'HP DC5100 SFF dotato di Pentium 4 Processor 640 with HT Technology  2.8 GHz poteva fare calcolo parallelo
Digitando lscpu e' apparso uno sconfortante

Architecture: i686
CPU op-mode(s):  32-bit, 64-bit
Byte Order:  Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
Vendor ID:  GenuineIntel
CPU family:  15
Model:  4
Stepping:  9
CPU MHz:  2793.347
BogoMIPS:  5586.69
L1d cache: 16K
L2 cache: 1024K

In un solo core con un solo thread?? Il problema e' stato risolto entrando nel BIOS ed abilitando lo switch dell'Hyperthreading. Una volta riavviata la macchina il risultato e' stato

Architecture:          i686
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                2
On-line CPU(s) list:   0,1
Thread(s) per core:    2
Core(s) per socket:    1
Socket(s):             1

Per testare l'effettivo utilizzo di HyperThreading ho usato il programma sotto riportato utilizzando OpenMP, una libreria per distribuire il calcolo

Il programma inizializza con il valore del seno un array molto grande, prima senza l'utilizzo di Hyperthreading e poi con

La prima prova, in modalita' standard, deve essere compilato con  g++ -Wall -O3 test_no.cpp -o test_no

---------------------------------------
#include <cmath>
#include <iostream>

using namespace std;

int main()
{
const int size = 100000;
double tabella[size];


for (int n=0; n<size;++n)
{
tabella[n] = sin(2*M_PI*n/size);
}
return 0;
}

---------------------------------------

La seconda, che utilizza invece OpenMP si compila con g++ -Wall -O3 test.cpp -o test -fopenmp

---------------------------------------
#include <cmath>
#include <omp.h>
#include <iostream>

using namespace std;

int main()
{
const int size = 100000;
double tabella[size];
int id;
int proc0,proc1;

#pragma omp parallel for
for (int n=0; n<size;++n)
{
id = omp_get_thread_num();
tabella[n] = sin(2*M_PI*n/size);
if (id == 1) proc1++;
else
proc0++;
}
cout << "0: "<< proc0 << "   |  1: "<<proc1;
return 0;
}

---------------------------------------

come si vede dall'output il carico di lavoro e' stato equamente diviso tra il thread 0 ed il thread 1 che hanno ciascuno effettutao 50000 cicli dei 100000 previsti
0: 50000   |  1: 50000

I tempi di caloolo sono pero' a favore della versione standard
Tempo con utilizzo dei thread
real 0m0.021s
user 0m0.020s
sys 0m0.012s

Tempo senza utilizzo dei thread

real 0m0.003s
user 0m0.000s
sys 0m0.004s

L'altra cosa divertente che ho scoperto e' che il mio Samsung N150 Plus esegue correttamente anche Debian a 64 Bit anche se,l leggendo qua e la', non ci sono particolari motivi di utilizzare 64 bit su una macchina con un solo Gb di Ram

Debian Live 64 Bit su N450