Multithread - reduzierter Wirkungsgrad, möglicherweise verursacht durch `false sharing`

Question

Ich muss 2 verschiedene Funktionen berechnen, die die gleichen Parameter verwenden (nur zum Lesen). Nachdem ich das Programm Multithread gemacht habe, braucht das Programm 2x (statt 0.5x). Ich bin neu in Multi-Thread-Programmierung, aber ich habe für false sharing vermutet.

Mein ursprünglicher Code (Schnitt):

#include <iostream> 

double frac_twins(double mu, double sigma,p){ 
    return 1; 
} 
double dist_twins(double mu, double sigma,p){ 
    return 2; 
} 

int main(){ 

int n_t=100; 

double* num_t = new double[n_t]; 
double* dist_t = new double[n_t]; 

double mu=2; double sigma=1; 
double num,dist; 

for(double p=0.001; p<=0.101;p+=0.001){ 

    num=frac_twins(mu,sigma,p); 
    dist=dist_twins(mu,sigma,p); 

     num_t[i]=num; 
     dist_t[i]=dist; 
     i++; 
} 

return 0; 
} 

funktioniert. Dann habe ich versucht, Threads zu verwenden:

#include <iostream> 
#include <thread> 

double frac_twins(double mu, double sigma,p){ 
    return 1; 
} 
double dist_twins(double mu, double sigma,p){ 
    return 2; 
} 

int main(){ 

int n_t=100; 

double* num_t = new double[n_t]; 
double* dist_t = new double[n_t]; 

double mu=2; double sigma=1; 
double num,dist; 

for(double p=0.001; p<=0.101;p+=0.001){ 

     std::thread t1([&num,mu,sigma,p](){ 
    num=frac_twins(mu,sigma,p); 
     }); 
     std::thread t2([&dist,mu,sigma,p](){ 
    dist=dist_twins(mu,sigma,p); 
     }); 

     t1.join(); 
     t2.join(); 

     num_t[i]=num; 
     dist_t[i]=dist; 
     i++; 
} 

return 0; 
} 

Was funktioniert, aber 2x mal langsamer. Dann habe ich versucht, zu ‚freien‘ Variablen ‚mu, sigma und p‘, aber es noch 2x mal langsamer:

#include <iostream> 
#include <thread> 

double frac_twins(double mu, double sigma,p){ 
    return 1; 
} 
double dist_twins(double mu, double sigma,p){ 
    return 2; 
} 

int main(){ 

int n_t=100; 

double* num_t = new double[n_t]; 
double* dist_t = new double[n_t]; 

double mu=2; double sigma=1; 
double mu2=2; double sigma2=1; double p2; 

double num,dist; 

for(double p=0.001; p<=0.101;p+=0.001){ 

     std::thread t1([&num,mu,sigma,p](){ 
    num=frac_twins(mu,sigma,p); 
     }); 
     mu2=mu; sigma2=sigma; p2=p; 
     std::thread t2([&dist,mu2,sigma2,p2](){ 
    dist=dist_twins(mu,sigma,p); 
     }); 

     t1.join(); 
     t2.join(); 

     num_t[i]=num; 
     dist_t[i]=dist; 
     i++; 
} 

return 0; 
} 

Answer 1

Die Funktionen, die Sie in Ihren Threads rufen tun so wenig Arbeit, die Kosten für die Inbetriebnahme Diese Threads übersteigen den Gewinn, den Sie durch die Verwendung mehrerer Threads erzielen. Falsches Teilen hat damit nichts zu tun.

Da mu, sigma und p Wert übergeben werden, können diese zwischen den beiden Threads gemeinsam genutzt werden (und in jedem Fall werden als Teil der Overhead-Lambda-Funktion kopiert).