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

Question

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

#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!!\n";
        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 000 строк

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

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

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

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

   windows shell:

   

   git bash оболочка

   

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

Answer 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
   }
   

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

   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 из нескольких потоков будет только смешивать строки. Кроме того, запись чего-либо обычно требует некоторой синхронизации, поэтому большую часть времени ваши потоки будут просто ждать. Не кажется полезным здесь использовать многопоточность.