Intel TBB vs Boost

Pero la biblioteca de subprocesos incluso necesita preocuparse por la asignación de subprocesos a núcleos. ¿no es esto un trabajo de sistema operativo? Entonces, ¿cuál es el beneficio real de usar TBB sobre Boost?

Tiene razón, una biblioteca de subprocesos generalmente no debería preocuparse por asignar subprocesos a núcleos. Y TBB no. TBB opera con tareas, no con hilos. El programador de TBB utiliza todos los núcleos asignando un grupo de subprocesos y permitiéndole seleccionar dinámicamente qué tareas ejecutar. Esta es la principal ventaja sobre Boost, con el que tendrá que mapear el trabajo disponible a los hilos manualmente. Y luego TBB ofrece construcciones de alto nivel como parallel_for, parallel_pipeline, etc. que se puede utilizar para expresar los patrones paralelos más comunes, y ocultar toda la manipulación con tareas.

Por ejemplo, tomemos un fragmento de código que calcula los puntos de Mandelbrot fractal (tomado de http://warp.povusers.org/Mandelbrot / , se omite la inicialización de la variable):

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); }
    }
}

Ahora para hacerlo en paralelo con TBB, todo lo que necesita es convertir el bucle más externo en tbb:: parallel_for (uso un lambda de C++11 para brevedad):

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 distribuirá automáticamente todas las iteraciones de bucle sobre los núcleos disponibles (y no te molestes en cuántos) y equilibrará dinámicamente la carga de modo que si algún subproceso tiene más trabajo que hacer, otros subprocesos no solo lo esperan sino que ayudan, maximizando la utilización de la CPU. Intenta implementarlo con hilos raw, y sentirás la diferencia:)