我有两个函数,可以对两个整数 vector 进行乘法(目前已全部填充)。我希望函数vector_multiplication_concurrent
能够比线程vector_multiplication
更快,该函数使用线程。但是,它实际上要慢一些。我怀疑这是因为一次仅一个线程可对result
变量进行操作,因此这些线程实际上并未并行执行该工作。这是正确的吗?我应该如何更改代码以使并行函数更快?
代码:
#include <iostream>
#include <chrono>
#include <vector>
#include <thread>
#include <mutex>
void vector_multiplication(std::vector<int> const & v1,
std::vector<int> const & v2,
int & result) {
for (int ind = 0; ind < v1.size(); ++ind) {
result += v1[ind] * v2[ind];
}
}
static std::mutex mtx;
void vector_multiplication_concurrent(std::vector<int> const & v1,
std::vector<int> const & v2,
int start_ind, int end_ind,
int & result) {
std::lock_guard<std::mutex> lck(mtx);
for (int ind = start_ind; ind <= end_ind; ++ind) {
result += v1[ind] * v2[ind];
}
}
int main(){
std::vector<int> v1 (10000000, 1);
std::vector<int> v2 (10000000, 1);
int result = 0;
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
vector_multiplication(v1, v2, result);
std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
std::cout << "Duration: " << duration << '\n';
std::cout << "Product: " << result << '\n';
int result_concurrent = 0;
int threads_num = 4;
std::vector<std::thread> threads;
std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
for (int th = 0; th < threads_num; ++th) {
threads.push_back(std::thread(vector_multiplication_concurrent,
std::ref(v1),
std::ref(v2),
th * (v1.size() / threads_num),
th * (v1.size() / threads_num) + v1.size() / threads_num - 1,
std::ref(result_concurrent)));
}
for (auto & th : threads) {
th.join();
}
std::chrono::high_resolution_clock::time_point t4 = std::chrono::high_resolution_clock::now();
auto duration_concurrent = std::chrono::duration_cast<std::chrono::microseconds>(t4 - t3).count();
std::cout << "Duration concurrent: " << duration_concurrent << '\n';
std::cout << "Product concurrent: " << result_concurrent << '\n';
return 0;
}
最佳答案
如注释中所述,您在函数的整个过程中都锁定互斥锁,因此代码实际上是顺序的。
仅当多个线程访问同一内存并且至少有一个正在写入时,才需要使用互斥锁。
如果对 vector 元素求和,则在添加最终结果时只需要使多个线程写入同一内存即可,因此可以将函数更改为:
static std::mutex mtx;
void vector_multiplication_concurrent(std::vector<int> const & v1,
std::vector<int> const & v2,
int start_ind, int end_ind,
int & result) {
// fully parallel part
// v1 and v2 are shared, but you are only reading
int temp = 0;
for (int ind = start_ind; ind <= end_ind; ++ind) {
temp += v1[ind] * v2[ind];
}
// only this requires you to synchronize access
// result is shared and you are writing to it
std::lock_guard<std::mutex> lck(mtx);
result += temp;
}
PS:我强烈建议您使用迭代器而不是索引。还要注意,您的循环基本上是对
std::inner_product
的重写。使用它而不是简单的循环将使您的代码更具表现力。