Почему моя программа работает медленнее, несмотря на используя больше потоков? [closed]

El mutex es una pista falsa --es local para la función, por lo que en realidad no está bloqueando nada, ya que termina siendo un mutex separado para cada subproceso. Para bloquear realmente, necesitaría mover la variable mutex fuera de crear imagen _.

Sin embargo, las escrituras en la imagen son independientes, por lo que no es necesario bloquearla. Es decir, dado que cada llamada para crear una imagen _es para una región separada, las escrituras no se superponen. Usted garantiza que los cambios se registrarán uniéndose a los hilos para esperar a que se completen.

El problema es en realidad rand (). Según mis pruebas, tiene su propio bloqueo de mutex interno que está causando toda la desaceleración. Cambiar de rand ()a rand _r (&seed )hace toda la diferencia. Cuantos más subprocesos se utilicen, más caro se vuelve el bloqueo (por llamada ), por lo que se ve una ralentización.

Habiendo dicho eso, en mi CPU, la creación de PNG es el costo dominante en este programa. Sin escribir la imagen PNG, el programa se ejecuta en menos de 2 segundos (de un solo hilo )y se escala casi linealmente con la cantidad de núcleos utilizados. Al escribir la imagen PNG, ese tiempo salta a más de 8 segundos, por lo que escribir la imagen PNG lleva mucho más tiempo que crear la imagen.

Esto es lo que se me ocurrió:

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <png++/png.hpp>
#include <time.h>

std::vector<int> bounds(int max, int parts)
{
    std::vector<int> interval;
    int gap = max / parts;
    int left = max % parts;
    int nr1 = 0;
    int nr2;

    interval.push_back(nr1);
    for (int i = 0; i < parts; i++)
    {
        nr2 = nr1 + gap;
        if (i == parts - 1)
            nr2 += left;
        nr1 = nr2;
        interval.push_back(nr2);
    }
    return interval;
}

void create_image(png::image<png::rgb_pixel> &image, int start, int end)
{
    unsigned int seed = time(NULL);
    for (int i = start; i < end; i++)
        for (int j = 0; j < image.get_height(); j++)
            image[i][j] = png::rgb_pixel(rand_r(&seed) % 256, 0, rand_r(&seed) % 256);
}

int main()
{
    png::image<png::rgb_pixel> png_image(6000, 6000);                  //Creating Image
    int parts = 1;                                                     //amount of parallel threads
    std::vector<int> my_vector = bounds(png_image.get_width(), parts); //interval vector
    std::vector<std::thread> workers;                                  //threads

    time_t start, end;
    time(&start); //measuring time
    for (int i = 0; i < parts; i++)
    {
        workers.push_back(std::thread(create_image, std::ref(png_image), my_vector[i], my_vector[i + 1]));
    }
    for (int i = 0; i < parts; i++)
        workers[i].join();

    png_image.write("test.png");
    time(&end);
    std::cout << (end - start) << " seconds\n";

    return 0;
}