Intel TBB vs Boost

Mais la bibliothèque de threads a-t-elle même besoin de s'inquiéter de l'allocation des threads aux cœurs. n'est-ce pas un travail de système d'exploitation? Alors, quel est le vrai avantage d'utiliser TBB sur Boost?

Vous avez raison, une bibliothèque de threads ne devrait généralement pas se soucier du mappage des threads aux cœurs. Et TBB ne le fait pas. TBB fonctionne avec des tâches, pas des threads. Le planificateur de TBB utilise tous les cœurs en allouant un pool de threads et en le laissant sélectionner dynamiquement les tâches à exécuter. C'est le principal avantage sur Boost, avec lequel vous devrez mapper le travail disponible aux threads manuellement. Et puis TBB propose des constructions de haut niveau telles que parallel_for, parallel_pipeline, etc. cela peut être utilisé pour exprimer les motifs parallèles les plus courants et masquer toute manipulation avec des tâches.

Par exemple, prenons un morceau de code qui calcule les points de Mandelbrot fractal (tiré de http://warp.povusers.org/Mandelbrot / , initialisation de variable omise):

for(unsigned y=0; y<ImageHeight; ++y)
{
    double c_im = MaxIm - y*Im_factor;
    for(unsigned x=0; x<ImageWidth; ++x)
    {
        double c_re = MinRe + x*Re_factor;

        double Z_re = c_re, Z_im = c_im;
        bool isInside = true;
        for(unsigned n=0; n<MaxIterations; ++n)
        {
            double Z_re2 = Z_re*Z_re, Z_im2 = Z_im*Z_im;
            if(Z_re2 + Z_im2 > 4)
            {
                isInside = false;
                break;
            }
            Z_im = 2*Z_re*Z_im + c_im;
            Z_re = Z_re2 - Z_im2 + c_re;
        }
        if(isInside) { putpixel(x, y); }
    }
}

Maintenant pour le faire parallèlement à TBB, tout ce dont vous avez besoin est de convertir la boucle la plus externe en tbb:: parallel_for (j'utilise un lambda C++11 pour plus de concision):

tbb::parallel_for(0, ImageHeight, [=](unsigned y)
{
    // the rest of code is exactly the same
    double c_im = MaxIm - y*Im_factor;
    for(unsigned x=0; x<ImageWidth; ++x)
    {
        ...
        // if putpixel() is not thread safe, a lock might be needed
        if(isInside) { putpixel(x, y); }
    }
});

TBB distribuera automatiquement toutes les itérations de boucle sur les cœurs disponibles (et vous ne dérangerez pas combien) et équilibrera dynamiquement la charge de sorte que si un thread a plus de travail à faire, d'autres threads ne l'attendent pas mais aident, maximisant l'utilisation du processeur. Essayez de l'implémenter avec des threads bruts, et vous sentirez la différence:)