Разница во времени выполнения в оболочке Windows и Git Bash в Windows 7

У меня есть пример кода для оптимизации

#include <iostream>
#include <vector>
#include <memory>
#include <fstream>
#include <assert.h>
#include <pthread.h>
#include <unistd.h>

template<typename NumType=float>
void RenderSphereOnScreen(const NumType* const _coords)
{
   std::cout<<_coords[0]<<" "<<_coords[1]<<" "<<_coords[2]<<std::endl; //assume
}

template<typename NumType>
class SphereRenderTask
{
    NumType  _coords[3];
    public:
 SphereRenderTask(const NumType& x, const NumType& y, const NumType& z)
{
    if(std::is_same<NumType, int>::value || std::is_same<NumType, float>::value || std::is_same<NumType, double>::value)
    {
        _coords[0] = x;
        _coords[1] = y;
        _coords[2] = z;
    }
    else
    {
        std::cout << "Error.unknown class type!!
";
        assert(0);
    }
}
 void operator()() const
 {
    RenderSphereOnScreen(_coords);
 }
};

std::vector<SphereRenderTask<double>*> taskList;
const int THREADS = 3;
void *renderThread(void *index)
{
    int tid = *((int *)index);
    int max = -1;
    int i = tid*(taskList.size()/THREADS);
    max = (tid+1)*(taskList.size()/THREADS);

    for( std::vector<SphereRenderTask<double>*>::iterator iter=taskList.begin() + i; i<max;)
    {
        (**iter)();
        i++;
        iter++;
    }

}

void StartRendering(const char* const inputFilePath)
{
    void sequential_render();
    void multithreaded_render();
   taskList.clear(); //init
   std::ifstream inputfile(inputFilePath);

   double x,y,z;

   while (inputfile >> x >> y>> z)
   {
     taskList.push_back(new SphereRenderTask<double>(x,y,z));
   }
    int y1 = taskList.size();
    inputfile.close();



    if(!THREADS)
        sequential_render();
    else
        multithreaded_render();
}

void sequential_render()
{
    for(std::vector<SphereRenderTask<double>*>::iterator iter=taskList.begin(); iter!=taskList.end(); ++iter)
    {
       (**iter)();
    }
}
void multithreaded_render()
{
    pthread_t tid[THREADS];
    for(int i=0;i<THREADS;i++)
    {
       int tmp = i;
       pthread_create(&tid[i], NULL, renderThread, &tmp);
       pthread_join(tid[i], NULL);
    }
}

int main(int argc, const char* argv[])
{
    StartRendering("sphere.txt");
    return 0;
}

что это делает:

  1. читает имя файла "phere.txt ", который содержит 100 тыс. строк (x, y, z), которые могут быть плавающими

    Пример:

     136 562 293
     629 399 497
     682 642 995
     739 351 869
     607 968 7
     262 788 863
    .... 
    

    так до 100к строк

  2. сохранить те в структуре данных, вектор указателя taskList

  3. затем отобразить на экране, используя sequential_render или multithreaded_render

У меня есть два вопроса по этому поводу:

  1. выполнение этого дает время выполнения diff для оболочки Windows и оболочки git bash, как для Windows (компилятор mingw g ++ 5.1.0)

    оболочка Windows:

    введите описание изображения здесь

    Git Bash Shell

    введите описание изображения здесь

  2. почему использование многопоточности не улучшает время выполнения? Я пробовал это как на Windows, так и на Linux.

Всего 1 ответ


Небольшое заключение здесь:

  1. Это просто так. CMD ужасно медленно. Этот вопрос объясняет это немного и предоставляет некоторые ссылки, которые могут быть интересны.

  2. На самом деле у вас нет многопоточности:

    pthread_t tid[THREADS]; // Array of threads
    
    for(int i=0;i<THREADS;i++)
    {
        int tmp = i;
        pthread_create(&tid[i], NULL, renderThread, &tmp); // Create one thread
        pthread_join(tid[i], NULL); // wait for it to complete
    }
    

    Так сколько потоков работает в любой момент времени? Правильно, только один. Таким образом, основное время для печати элементов остается таким же, как в однопоточной версии, но создание и присоединение к потоку требует времени, которое не требуется в однопоточной версии. Правильное использование многопоточности будет:

    pthread_t tid[THREADS]; // Array of threads
    int tmps[THREADS]; // each thread wants it's own tmp
    
    //start all the threads
    for(int i = 0; i < THREADS; i++)
    {
        tmps[i] = i;
        pthread_create(&tid[i], NULL, renderThread, &tmps[i]);
    }
    
    // join them all
    for(int i = 0; i < THREADS; i++)
    {
        pthread_join(tid[i], NULL); // wait for it to complete
    }
    

Но, как я уже упоминал в своем комментарии, запись в std::cout из нескольких потоков будет только смешивать строки. Кроме того, запись чего-либо обычно требует некоторой синхронизации, поэтому большую часть времени ваши потоки будут просто ждать. Не кажется полезным использовать потоки здесь.


Есть идеи?

10000