Question

为什么copy_if的工作速度慢然后复制

我目前正在使用OpenGL图形引擎。我正在尝试找出将大量对象传递给GPU进行实例化绘制的最佳方法。对我来说最大的问题是某些对象可能会失效，因此我创建了一个小测试。

这是我正在测试的简单结构（在实际应用中，它将是位置+颜色等）

struct foo
{
   bool is_active = false;
   float value = 0.0f;
};

此后，我创建了这些容器：

// All data
std::vector<foo> data_vector;
// Data that is only active
std::vector<foo> active_vector;
using distance_t = vector<foo>::iterator::difference_type;
// List of segments, so that if we have 10 elements where
// only the 5th is not active it is going to look like that
// { {0,5}, {6, 10} }
std::list<pair<distance_t, distance_t>> active_segments;

向量中1,000,000个元素的保留空间。用所有真实值填充 data_vector 。还要填充列表以忽略分配时间。并使用 high_resolution_clock

测试了这3个复制功能的速度

// First method
// For all true values *active_segments* has only one element with 
// {0, 1000000}
for_each(active_segments.begin(), active_segments.end(), 
              [&active_vector, data_vector](auto current)
    {
      copy(data_vector.begin() + current.first, 
      data_vector.begin() + current.second, 
      std::back_inserter(active_vector));
    });

// Second method
copy_if(data_vector.begin(), data_vector.end(),
        std::back_inserter(active_vector), 
        [](const foo &current)
        {
           return current.is_active;
        });

// Third method
copy(data_vector.begin(), data_vector.end(), 
     std::back_inserter(active_vector));

很明显， copy 是最快的，只有18024微秒。但是令我惊讶的是， copy_if 更快（27777微秒），然后是第一种方法（33278微秒）。

我不明白为什么会这样。我想增加一些内存分配，但要增加复制速度，但是结果是即使在最佳条件下，我的方法也较慢。

Answer 1

在我看来，您（至少）是两个导致问题的因素的组合。

第一个是一个实际的问题：在lambda中，您是通过值而不是引用来捕获data_vector，因此，您要复制整个输入数组，然后将数据从该副本复制到结果中。

第二个主要针对基准测试：缓存预热。如果我修复了lambda以便通过引用捕获它，则您的方法1的运行仍然比其他两种方法慢得多。但是，如果我在其前面添加了一个简单的缓存警告循环：

for (int i = 0; i < size; i++)
    active_vector.push_back(data_vector[i]);

...然后我可以同时运行所有三个，并且它们都以足够快的速度运行，以至于我无法再确定一个比另一个要快。

另一方面，我认为这也表明整个练习是毫无意义的-尽管从理论上讲copy_if应该比copy慢一点（按每个元素），我发现两者之间没有任何显着差异。我怀疑在大多数情况下，内存带宽是限制因素，而弄清楚是否要复制某些内容的额外处理时间只是在噪声中损失了。实际上，有时候，第二个版本（使用copy_if）的发布速度最快，而第三个版本（使用copy）的发布速度最快：

method 1:   3,295us
method 2:   3,178us
method 3:   3,839us

就它的价值而言，这是我运行它的代码：

#include <algorithm>
#include <chrono>
#include <iostream>
#include <vector>
#include <list>
#include <utility>

struct foo
{
    bool is_active = true;
    float value = 0.0f;
};

int main() {

    const int size = 1'000'000;

    std::cout.imbue(std::locale(""));

    // All data
    std::vector<foo> data_vector(size);
    // Data that is only active
    std::vector<foo> active_vector;

    using distance_t = std::vector<foo>::iterator::difference_type;
    // List of segments, so that if we have 10 elements where
    // only the 5th is not active it is going to look like that
    // { {0,5}, {6, 10} }
    std::vector<std::pair<distance_t, distance_t>> active_segments;

    using namespace std::chrono;

    // Warm the cache:
    for (int i = 0; i < size; i++)
        active_vector.push_back(data_vector[i]);

    {
        active_segments.emplace_back(0, size);

        active_vector.clear();
        active_vector.reserve(size);
        auto begin = high_resolution_clock::now();

        for_each(active_segments.begin(), active_segments.end(),
            [&active_vector, &data_vector](auto current)
        {
            copy(data_vector.begin() + current.first,
                data_vector.begin() + current.second,
                std::back_inserter(active_vector));
        });
        auto end = high_resolution_clock::now();

        std::cout << "method 1:   " << duration_cast<microseconds>(end - begin).count() << "us\n";
    }

    {
        active_vector.clear();
        active_vector.reserve(size);
        auto begin = high_resolution_clock::now();
        // Second method
        copy_if(data_vector.begin(), data_vector.end(),
            std::back_inserter(active_vector),
            [](const foo &current)
        {
            return current.is_active;
        });
        auto end = high_resolution_clock::now();
        std::cout << "method 2:   " << duration_cast<microseconds>(end - begin).count() << "us\n";
    }

    {
        active_vector.clear();
        active_vector.reserve(size);
        auto begin = high_resolution_clock::now();
        copy(data_vector.begin(), data_vector.end(),
            std::back_inserter(active_vector));
        auto end = high_resolution_clock::now();

        std::cout << "method 3:   " << duration_cast<microseconds>(end - begin).count() << "us\n";
    }
}

可能还需要考虑一点：您是否还需要data_vector中不再有效的元素？如果不再需要它们，则可以使用std::remove_if将所有活动元素移到集合的开头，然后从那里删除到结尾。

auto e = std::remove_if(data_vector.begin(), data_vector.end(), 
                       [](auto const &e) {return e.is_active; });
data_vector.erase(e, data_vector.end());

对每个元素标记为活动或不活动的机会进行快速测试的可能性为50％，这大约是复制活动元素的速度的两倍。

copy_if vs保存序列并使用复制

1 个答案: