C++ async fonctionnant seulement sur un noyau?

Question

J'essaye actuellement d'implémenter SMP paresseux pour mon moteur d'échecs, ce qui implique l'exécution de l'algorithme de recherche sur différents cœurs (aussi désynchronisé que possible) et (espérons-le) récolter les avantages d'une table de hachage partagée. Il ne fonctionne toujours que sur un seul noyau. Code ci-dessous (j'ai supprimé les parties qui ne sont pas pertinentes).

boucle d'approfondissement itératifs:

for(distance; distance <= depth && IDTimeS < endTime;) { 

    positionCount = 0; 
    clock_t currentTime = clock(); 

    if(currentTime >= endTime) { 
     distance - 1; 
     break; 
    }  

    //multi threading testing 
    int val = multi(distance, alpha, beta, false, currentTime, timeLimmit, currentDepth +1, true, z0, z1, z2); 

    //increment distance to travel (same as depth at max depth) 
    distance++; 
} 

fonction multi-threading:

int Ai_Logic::multi(
    int distance, 
    int alpha, 
    int beta, 
    bool isWhite, 
    long currentTime, 
    long timeLimmit, 
    int currentDepth, 
    bool allowNull, 
    ZobristH *z0, 
    ZobristH *z1, 
    ZobristH *z2 
) 
{ 
    auto f1 = std::async(std::launch::async, &Ai_Logic::alphaBeta, this, distance, alpha, beta, isWhite, currentTime, timeLimmit, currentDepth, allowNull, BB0, z0); 
    auto f2 = std::async(std::launch::async, &Ai_Logic::alphaBeta, this, distance-1, alpha, beta, isWhite, currentTime, timeLimmit, currentDepth, allowNull, BB1, z1); 
    auto f3 = std::async(std::launch::async, &Ai_Logic::alphaBeta, this, distance+1, alpha, beta, isWhite, currentTime, timeLimmit, currentDepth, allowNull, BB2, z2); 

    auto val = f1.get(); 
    auto val2 = f2.get(); 
    auto val3 = f3.get(); 

    return val; 
} 

Y at-il une raison évidente que je manque la raison pour laquelle il est toujours seulement en utilisant un noyau?

Answer 1

Compris ce qui est au moins un travail autour du problème que j'avais. Tant que les threads sont créés avant la boucle d'approfondissement itérative et rejoint après que je reçois définitivement l'utilisation multi-core.

std::thread t0(&Ai_Logic::alphaBeta, this, depth+1, alpha, beta, false, 0, timeLimmit, currentDepth, true, BB0, z0); 
std::thread t1(&Ai_Logic::alphaBeta, this, depth-1, alpha, beta, false, 0, timeLimmit, currentDepth, true, BB1, z1); 

for(distance; distance <= depth && IDTimeS < endTime;) { 

positionCount = 0; 
clock_t currentTime = clock(); 

if(currentTime >= endTime) { 
    distance - 1; 
    break; 
}  

//normal alpha beta call 
int val = alphaBeta(distance, alpha, beta, false, currentTime, timeLimmit, currentDepth +1, true, newBoard, mZobrist); 


//increment distance to travel (same as depth at max depth) 
distance++; 
} 

t0.join(); 
t1.join();