멀티쓰레딩 예제 실행시간 재질문

말씀하신 코드는 다음과 같습니다

#include<iostream>

#include<chrono>

#include<mutex>

#include<random>

#include<thread>

#include<utility>

#include<vector>

#include<atomic>

#include<future>

#include<numeric> //std::inner_product

#include<execution> // parallel_execution

using namespace std;

mutex mtx;

void dotProducNaive(const vector<int>& v0, const vector<int>& v1,

const unsigned i_start, const unsigned i_end, unsigned long long& sum)

{

for (unsigned i = i_start; i < i_end ; i++)

{

sum += (v0[i] * v1[i]);

//내적 구현 한 것

}

}

void dotProductLock(const vector<int>& v0, const vector<int>& v1,

const unsigned i_start, const unsigned i_end, unsigned long long& sum)

{

//cout<<"Thread start"<<endl;

for (unsigned i = i_start; i < i_end; i++)

{

std::scoped_lock lock(mtx); //c++17

sum += v0[i] * v1[i];

}

}

void dotProducAtomic(const vector<int>& v0, const vector<int>& v1,

const unsigned i_start, const unsigned i_end, atomic<unsigned long long>& sum)

{

for (unsigned i = i_start; i < i_end ; i++)

{

sum += (v0[i] * v1[i]);

//내적 구현 한 것

}

}

int main()

{

const long long n_data = 100'000'000;

const unsigned n_threads = 8;

//initialize vectors

std::vector<int> v0, v1;

v0.reserve(n_data);

v1.reserve(n_data);

random_device seed;

mt19937 engine(seed());

uniform_int_distribution <> uniformDist(1, 10);

for (long long i = 0; i < n_data; i++)

{

v0.push_back(uniformDist(engine));

v1.push_back(uniformDist(engine));

}

cout << "std::inner_product" << endl;

{

const auto sta = chrono::steady_clock::now(); //시간 재는중

const auto sum = std::inner_product(v0.begin(), v0.end(), v1.begin(), 0ull);

const chrono::duration<double> dur = chrono::steady_clock::now() - sta; //시간 재는 중

//계산한 시간 출력

cout << dur.count() << endl;

cout << sum << endl;

cout << endl;

}

cout << "Native" << endl;

{

const auto sta = chrono::steady_clock::now();

unsigned long long sum = 0;

vector<thread> threads;

threads.resize(n_threads);

//쓰레드 마다 맡길 일의 양을 결정

const unsigned n_per_thread = n_data / n_threads; //assumes remainder=0

//쓰레드 할당 중 + 쓰레드에 값을 넣어주는 중

for (unsigned t = 0; t < n_threads; t++)

{

threads[t] = std::thread(dotProducNaive,std::ref(v0),std::ref(v1),

t* n_per_thread, (t + 1)* n_per_thread, std::ref(sum));

}

//join으로 기다리는 코드

for (unsigned t = 0; t < n_threads; t++)

{

threads[t].join();

}

const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

cout << dur.count() << endl;

cout << sum << endl;

cout << endl;

}

cout << "Lock guard" << endl;

{

const auto sta = chrono::steady_clock::now();

unsigned long long sum = 0;

vector<thread> threads;

threads.resize(n_threads);

//쓰레드 마다 맡길 일의 양을 결정

const unsigned n_per_thread = n_data / n_threads; //assumes remainder=0

//쓰레드 할당 중 + 쓰레드에 값을 넣어주는 중

for (unsigned t = 0; t < n_threads; t++)

{

threads[t] = std::thread(dotProductLock, std::ref(v0), std::ref(v1),

t * n_per_thread, (t + 1) * n_per_thread, std::ref(sum));

}

//join으로 기다리는 코드

for (unsigned t = 0; t < n_threads; t++)

{

threads[t].join();

}

const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

cout << dur.count() << endl;

cout << sum << endl;

cout << endl;

}

cout << "atomic" << endl;

{

const auto sta = chrono::steady_clock::now();

atomic<unsigned long long> sum = 0;

vector<thread> threads;

threads.resize(n_threads);

//쓰레드 마다 맡길 일의 양을 결정

const unsigned n_per_thread = n_data / n_threads; //assumes remainder=0

//쓰레드 할당 중 + 쓰레드에 값을 넣어주는 중

for (unsigned t = 0; t < n_threads; t++)

{

threads[t] = std::thread(dotProducAtomic, std::ref(v0), std::ref(v1),

t * n_per_thread, (t + 1) * n_per_thread, std::ref(sum));

}

//join으로 기다리는 코드

for (unsigned t = 0; t < n_threads; t++)

{

threads[t].join();

}

const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

cout << dur.count() << endl;

cout << sum << endl;

cout << endl;

}

return 0;

}

 for (long long i = 0; i < n_data; i++)

 {

 v0.push_back(uniformDist(engine));

 v1.push_back(uniformDist(engine));

 }