mahatma andi
Cadet 4th Year
- Registriert
- Jan. 2007
- Beiträge
- 97
Hallo Leute,
Ich habe gestern eine einfache Implementation eines Monte Carlo Integrals geschrieben. Einmal mit pthreads und einmal 'normal'. Da die Threads, bis sie ihr Ergebnis haben, nicht kommunizieren müssen, sollte das eigentlich extrem einfach zu parallelisieren sein.
Nun ist jedoch die pthread-Version durchgehend langsamer als die normale Version, obwohl die pthread Version 4 mal weniger Rechnen muss (4 threads). Dabei nimmt die Dauer, die das pthread-Programm braucht, um auszuführen, mit der Anzahl Threads zu.
Nun habe ich ein (möglichst einfaches) Beispielprogram zum Vergleich geschrieben, um zu sehen, ob es an Mutex usw. liegt beim Monte-Carlo-Integral. Diese beiden Beispielcodes, einmal pthread, einmal normal, addieren in einer Funktion 'Kernel' ein paar loop-Indizes und geben dann kein Ergebniss zurück, da das fürs Minimalbeispiel egal ist.
Auch hier ist die pthread-Version deutlich langsamer, etwa Faktor 'Anzahl Threads'. Kann mir jemand erklären wieso? Die Kerne sind beim Pthread alle voll ausgelastet, irgendwas wird also gerechnet, Kommunikation zwischen den Threads ist auch nicht nötig. Dass der pthread-Overhead so riesig ist, kann ich mir auch nicht vorstellen...
Hier die Codes:
pthread:
singlethread:
Falls jemand Lektüre zum Thema empfehlen kann, wäre ich dankbar.
Danke im Voraus,
Mahatma
Ich habe gestern eine einfache Implementation eines Monte Carlo Integrals geschrieben. Einmal mit pthreads und einmal 'normal'. Da die Threads, bis sie ihr Ergebnis haben, nicht kommunizieren müssen, sollte das eigentlich extrem einfach zu parallelisieren sein.
Nun ist jedoch die pthread-Version durchgehend langsamer als die normale Version, obwohl die pthread Version 4 mal weniger Rechnen muss (4 threads). Dabei nimmt die Dauer, die das pthread-Programm braucht, um auszuführen, mit der Anzahl Threads zu.
Nun habe ich ein (möglichst einfaches) Beispielprogram zum Vergleich geschrieben, um zu sehen, ob es an Mutex usw. liegt beim Monte-Carlo-Integral. Diese beiden Beispielcodes, einmal pthread, einmal normal, addieren in einer Funktion 'Kernel' ein paar loop-Indizes und geben dann kein Ergebniss zurück, da das fürs Minimalbeispiel egal ist.
Auch hier ist die pthread-Version deutlich langsamer, etwa Faktor 'Anzahl Threads'. Kann mir jemand erklären wieso? Die Kerne sind beim Pthread alle voll ausgelastet, irgendwas wird also gerechnet, Kommunikation zwischen den Threads ist auch nicht nötig. Dass der pthread-Overhead so riesig ist, kann ich mir auch nicht vorstellen...
Hier die Codes:
pthread:
Code:
#include <stdio.h>
#include <time.h>
#include <pthread.h>
#define N 1000000000.f
#define Nthreads 4
void *kernel(void* arguments);
int main(){
clock_t start, finish;
double cpu_time_used;
start = clock();
pthread_t thread_ID[Nthreads];
void *exit_status;
float arguments = 1;
int i;
for( i=0; i<Nthreads; i++){
pthread_create( &thread_ID[i], NULL, kernel, &arguments);
}
for( i=0; i<Nthreads; i++){
pthread_join( thread_ID[i], &exit_status);
}
finish = clock();
cpu_time_used = ((double) (finish - start) / CLOCKS_PER_SEC );
printf("time elapsed is %f\n", cpu_time_used);
return 0;
}
void *kernel(void* arguments){
int i;
float *arg;
arg = (float*) arguments;
for( i=0; i<((float)N/Nthreads); i++){
*arg += i;
}
}singlethread:
Code:
#include <stdio.h>
#include <time.h>
#define N 1000000000.f
void kernel(float argument);
int main(){
clock_t start, finish;
double cpu_time_used;
start = clock();
float result = 0;
float input = 0;
kernel( input);
finish = clock();
cpu_time_used = ((double) (finish - start) / CLOCKS_PER_SEC );
printf("time elapsed is %f\n", cpu_time_used);
return 0;
}
void kernel(float argument){
int i;
int l;
for( l=0; l<4; l++){
for( i=0; i<N/4; i++){
argument += i;
}
}
}Falls jemand Lektüre zum Thema empfehlen kann, wäre ich dankbar.
Danke im Voraus,
Mahatma
Du musst keine Milliarden Zufallszahlen vorberechnen, und jeder Thread kann lokal für sich seine Zufallszahlen berechnen. Keinerlei Inter-Thread-Kommunikation, keine Mutexe, keine nichts.
