鉴于这段代码。
struct T
{
void f(int const);
};
void f(std::vector<T> &u, std::vector<int> const &v)
{
for (std::size_t i = 0; i < u.size(); ++i)
u[i].f(v[i]);
}
有没有一个标准的方法来并行处理这段代码?void f(std::vector<T> &u, std::vector<int> const &v)
?
这恰好是偶然的工作(https:/godbolt.orgzgRv9Ze):
void f(std::vector<T> &u, std::vector<int> const &v)
{
auto const indices = std::views::iota(0u, u.size()) | std::views::common;
std::for_each(std::execution::par_unseq, std::begin(indices), std::end(indices),
[&](std::size_t const i) { u[i].f(v[i]); });
}
但据报道,依赖这种行为是错误的(见此 错误报告而这 回答). 事实上,这并不是并行运行的(https:/godbolt.orgzMPGdHF):
void f(std::vector<T> &u, std::vector<int> const &v)
{
std::ranges::iota_view<std::size_t, std::size_t> const indices(0u, u.size());
std::for_each(std::execution::par_unseq, std::begin(indices), std::end(indices),
[&](std::size_t const i) { u[i].f(v[i]); });
}
我相信应该有一个标准的方法 可以让这样的函数并行运行。我可能漏掉了一个明显的算法,但是...。std::transform
在这里似乎并不合适,其他的就更不合适了。
保持在 std
你最好的选择是 std::transform
输出迭代器,忽略给它的内容。
struct unit_iterator {
using difference_type = std::ptrdiff_t;
using value_type = std::tuple<>;
using pointer = std::tuple<> *;
using const_pointer = const std::tuple<> *;
using reference = std::tuple<> &;
using const reference = const std::tuple<> &;
using iterator_category = std::random_access_iterator_tag;
reference operator*() { return value; }
const_reference operator*() const { return value; }
reference operator[](difference_type) { return value; }
const_reference operator[](difference_type) const { return value; }
pointer operator->() { return &value; }
const_pointer operator->() const { return &value; }
unit_iterator& operator++() { return *this; }
unit_iterator operator++(int) { return *this; }
unit_iterator& operator+=(difference_type) { return *this; }
unit_iterator operator+(difference_type) const { return *this; }
unit_iterator& operator--() { return *this; }
unit_iterator operator--(int) { return *this; }
unit_iterator& operator-=(difference_type) { return *this; }
unit_iterator operator-(difference_type) const { return *this; }
difference_type operator-(unit_iterator) const { return 0; }
bool operator==(unit_iterator) const { return true; }
bool operator!=(unit_iterator) const { return false; }
bool operator<(unit_iterator) const { return false; }
bool operator<=(unit_iterator) const { return true; }
bool operator>(unit_iterator) const { return false; }
bool operator>=(unit_iterator) const { return true; }
private:
static value_type value;
};
void f(std::vector<T> &u, std::vector<int> const &v)
{
std::transform(std::execution::par_unseq, begin(u), end(u), begin(v), unit_iterator{},
[](T & u, int v) { u.f(v); return std::tuple<>{}; });
}