Wie verbessert man Multithread-Performance in C++

Question

Hier ist der Hauptteil meines Codes, um es zu beschleunigen Ich benutze Multithread, die unten zeigt, so ist meine Grundidee, sie einfach in 12 Teile zu klumpen und lassen Sie uns ihre Arbeit machen separat

int Thread_num=12; 
    int firstone=0; 
    int lastone=vector.size(); 
    int chunk = (lastone-firstone+(Thread_num-1))/Thread_num; 
    std::thread t[Thread_num];  
    for(int i=0;i<Thread_num;i++) 
{ 
    int s =firstone+i*chunk; 
    int e = ((s+chunk)<vector.size())? (s+chunk) : vector.size(); 

    t[i]=std::thread(calculateAll,data,arr,s,e);   
} 
for (int i = 0; i < Thread_num; ++i) 
{ 
    t[i].join(); 
} 

und hier ist die calculateAll Funktion (nicht genauer Code), und ich verwende Schloss push_back Teil verriegeln sie in diesen list Vektor zur gleichen Zeit schreiben zu vermeiden (die Reihenfolge spielt keine Rolle).

void calculateAll(int ***data,LineIndex* arr,int s,int e) 
{ 
    for(int a=s;a<e;a++) 
    { 
    function_1(arr) /*do something with array(arr)*/ 
    result=function_2(data) /*do something with data*/ 
    mylock.lock(); 
    list.push_back(result);  
    mylock.unlock(); 
    } 
} 

Also theoretisch, wird das 12 Mal beschleunigt werden? Wenn ich diese Idee in meinem Code verwende, wird sie 5 bis 6 Mal schneller. Macht das Sinn? und kann ich etwas modifizieren, um die Leistung zu verbessern, vielleicht eine andere Methode verwenden? Appreciated

Answer 1

Das lock() und unlock() Leistung zu töten, machen Sie Ihren parallelen Algorithmus in eine mehr oder weniger serielle. Wie einer der Kommentare andeutet, geben Sie jedem Thread eine eigene Liste zum Speichern der Ergebnisse, und konsolidieren Sie die Ergebnisse, wenn alle Threads beendet sind.

Auf eine andere Weise, wenn Sie sagen, dass Ihr Server 14 Kerne hat, ist das tatsächliche, physikalische Kerne, oder sind es 7 Kerne, jeder mit zwei Hyper-Threads? Wenn es das letztere ist, interferieren die Hyper-Threads miteinander und Sie erhalten nicht die volle Beschleunigung, die Sie von separaten Kernen erhalten würden.