在C++中,从函数返回向量仍然是不好的做法吗？

Question

简短版本:在许多编程语言中返回大型对象(例如向量/数组)是很常见的.如果类有移动构造函数,这个样式现在在C++ 0x中是否可以接受,或者C++程序员认为它是奇怪/丑陋/可憎的？

长版本:在C++ 0x中,这仍然被认为是不好的形式？

std::vector<std::string> BuildLargeVector();
...
std::vector<std::string> v = BuildLargeVector();

传统版本如下所示:

void BuildLargeVector(std::vector<std::string>& result);
...
std::vector<std::string> v;
BuildLargeVector(v);

在较新的版本,则返回值从BuildLargeVector是一个rvalue,所以v将使用的移动构造函数来构造std::vector,假设(N)RVO不会发生.

甚至之前的C++ 0x第一形式常常是因为(N)RVO"有效"的.但是,(N)RVO由编译器决定.现在我们有rvalue引用,保证不会发生深度复制.

编辑:问题实际上与优化无关.所示的两种形式在现实世界的节目中具有几乎相同的性能.然而,在过去,第一种形式可能具有数量级更差的性能.因此,第一种形式是C++编程中的主要代码味道很长一段时间.不再了,我希望？

Answer 1

Dave Abrahams 对传递/返回值的速度进行了非常全面的分析.

简短的回答,如果你需要返回一个值然后返回一个值.不要使用输出引用,因为编译器无论如何都要这样做.当然有一些警告,所以你应该阅读那篇文章.

Answer 2

至少IMO,这通常是一个糟糕的主意,但不是出于效率原因.这是一个糟糕的主意,因为有问题的函数通常应该写成通过迭代器生成输出的通用算法.几乎任何接受或返回容器而不是在迭代器上运行的代码都应该被认为是可疑的.

不要误解我的意思:有时候传递类似于集合的对象(例如字符串)是有意义的,但对于引用的例子,我会考虑传递或返回向量一个糟糕的想法.

Answer 3

要点是:

复制省略和静脉阻塞可避免"可怕的副本"(落实这些优化编译器不是必需的,而且在某些情况下,它不能被应用)

C++ 0x RValue引用允许保证这一点的字符串/向量实现.

如果您可以放弃较旧的编译器/ STL实现,则可以自由地返回向量(并确保您自己的对象也支持它).如果您的代码库需要支持"较小"的编译器,请坚持旧样式.

不幸的是,这会对您的界面产生重大影响.如果C++ 0x不是一个选项,并且您需要保证,则可以在某些情况下使用引用计数或写时复制对象.但是,它们在多线程方面存在缺点.

(我希望C++中的一个答案简单明了,没有条件).

Answer 4

实际上,从C++ 11开始,复制的成本std::vector在大多数情况下都消失了.

但是,应该记住,构造新向量(然后对其进行破坏)的成本仍然存在,并且当您希望重用向量的容量时,使用输出参数而不是按值返回仍然很有用.这在C++核心指南的F.20中被记录为例外.

让我们比较一下:

std::vector<int> BuildLargeVector1(size_t vecSize) {
    return std::vector<int>(vecSize, 1);
}

有:

void BuildLargeVector2(/*out*/ std::vector<int>& v, size_t vecSize) {
    v.assign(vecSize, 1);
}

现在,假设我们需要numIter在紧密循环中调用这些方法,并执行一些操作.例如,让我们计算所有元素的总和.

使用BuildLargeVector1,你会做:

size_t sum1 = 0;
for (int i = 0; i < numIter; ++i) {
    std::vector<int> v = BuildLargeVector1(vecSize);
    sum1 = std::accumulate(v.begin(), v.end(), sum1);
}

使用BuildLargeVector2,你会做:

size_t sum2 = 0;
std::vector<int> v;
for (int i = 0; i < numIter; ++i) {
    BuildLargeVector2(/*out*/ v, vecSize);
    sum2 = std::accumulate(v.begin(), v.end(), sum2);
}

在第一个示例中,发生了许多不必要的动态分配/解除分配,在第二个示例中,通过使用旧方式的输出参数,重用已经分配的内存来防止这种情况.这种优化是否值得进行取决于分配/解除分配的相对成本与计算/变异值的成本相比.

基准

让我们的价值观发挥vecSize和numIter.我们将继续vecSize*numIter恒定,从而"在理论上",应该采取相同的时间(=有相同数量的分配和补充,具有完全相同的值),以及时间差只能来自成本分配,解除分配和更好地使用缓存.

更具体地说,让我们使用vecSize*numIter = 2 ^ 31 = 2147483648,因为我有16GB的RAM,这个数字确保分配不超过8GB(sizeof(int)= 4),确保我没有交换到磁盘(所有其他程序都关闭了,运行测试时我有~15GB可用.

这是代码:

#include <chrono>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>

class Timer {
    using clock = std::chrono::steady_clock;
    using seconds = std::chrono::duration<double>;
    clock::time_point t_;

public:
    void tic() { t_ = clock::now(); }
    double toc() const { return seconds(clock::now() - t_).count(); }
};

std::vector<int> BuildLargeVector1(size_t vecSize) {
    return std::vector<int>(vecSize, 1);
}

void BuildLargeVector2(/*out*/ std::vector<int>& v, size_t vecSize) {
    v.assign(vecSize, 1);
}

int main() {
    Timer t;

    size_t vecSize = size_t(1) << 31;
    size_t numIter = 1;

    std::cout << std::setw(10) << "vecSize" << ", "
              << std::setw(10) << "numIter" << ", "
              << std::setw(10) << "time1" << ", "
              << std::setw(10) << "time2" << ", "
              << std::setw(10) << "sum1" << ", "
              << std::setw(10) << "sum2" << "\n";

    while (vecSize > 0) {

        t.tic();
        size_t sum1 = 0;
        {
            for (int i = 0; i < numIter; ++i) {
                std::vector<int> v = BuildLargeVector1(vecSize);
                sum1 = std::accumulate(v.begin(), v.end(), sum1);
            }
        }
        double time1 = t.toc();

        t.tic();
        size_t sum2 = 0;
        {
            std::vector<int> v;
            for (int i = 0; i < numIter; ++i) {
                BuildLargeVector2(/*out*/ v, vecSize);
                sum2 = std::accumulate(v.begin(), v.end(), sum2);
            }
        } // deallocate v
        double time2 = t.toc();

        std::cout << std::setw(10) << vecSize << ", "
                  << std::setw(10) << numIter << ", "
                  << std::setw(10) << std::fixed << time1 << ", "
                  << std::setw(10) << std::fixed << time2 << ", "
                  << std::setw(10) << sum1 << ", "
                  << std::setw(10) << sum2 << "\n";

        vecSize /= 2;
        numIter *= 2;
    }

    return 0;
}

这是结果:

$ g++ -std=c++11 -O3 main.cpp && ./a.out
   vecSize,    numIter,      time1,      time2,       sum1,       sum2
2147483648,          1,   2.360384,   2.356355, 2147483648, 2147483648
1073741824,          2,   2.365807,   1.732609, 2147483648, 2147483648
 536870912,          4,   2.373231,   1.420104, 2147483648, 2147483648
 268435456,          8,   2.383480,   1.261789, 2147483648, 2147483648
 134217728,         16,   2.395904,   1.179340, 2147483648, 2147483648
  67108864,         32,   2.408513,   1.131662, 2147483648, 2147483648
  33554432,         64,   2.416114,   1.097719, 2147483648, 2147483648
  16777216,        128,   2.431061,   1.060238, 2147483648, 2147483648
   8388608,        256,   2.448200,   0.998743, 2147483648, 2147483648
   4194304,        512,   0.884540,   0.875196, 2147483648, 2147483648
   2097152,       1024,   0.712911,   0.716124, 2147483648, 2147483648
   1048576,       2048,   0.552157,   0.603028, 2147483648, 2147483648
    524288,       4096,   0.549749,   0.602881, 2147483648, 2147483648
    262144,       8192,   0.547767,   0.604248, 2147483648, 2147483648
    131072,      16384,   0.537548,   0.603802, 2147483648, 2147483648
     65536,      32768,   0.524037,   0.600768, 2147483648, 2147483648
     32768,      65536,   0.526727,   0.598521, 2147483648, 2147483648
     16384,     131072,   0.515227,   0.599254, 2147483648, 2147483648
      8192,     262144,   0.540541,   0.600642, 2147483648, 2147483648
      4096,     524288,   0.495638,   0.603396, 2147483648, 2147483648
      2048,    1048576,   0.512905,   0.609594, 2147483648, 2147483648
      1024,    2097152,   0.548257,   0.622393, 2147483648, 2147483648
       512,    4194304,   0.616906,   0.647442, 2147483648, 2147483648
       256,    8388608,   0.571628,   0.629563, 2147483648, 2147483648
       128,   16777216,   0.846666,   0.657051, 2147483648, 2147483648
        64,   33554432,   0.853286,   0.724897, 2147483648, 2147483648
        32,   67108864,   1.232520,   0.851337, 2147483648, 2147483648
        16,  134217728,   1.982755,   1.079628, 2147483648, 2147483648
         8,  268435456,   3.483588,   1.673199, 2147483648, 2147483648
         4,  536870912,   5.724022,   2.150334, 2147483648, 2147483648
         2, 1073741824,  10.285453,   3.583777, 2147483648, 2147483648
         1, 2147483648,  20.552860,   6.214054, 2147483648, 2147483648

(Intel i7-7700K @ 4.20GHz; 16GB DDR4 2400Mhz; Kubuntu 18.04)

符号:mem(v)= v.size()*sizeof(int)= v.size()*4在我的平台上.

毫不奇怪,当numIter = 1(即mem(v)= 8GB)时,时间完全相同.实际上,在这两种情况下,我们只在内存中分配一次8GB的巨大向量.这也证明使用BuildLargeVector1()时没有复制:我没有足够的RAM来复制!

当numIter = 2重用矢量容量而不是重新分配第二个矢量时,速度快1.37倍.

何时numIter = 256,重用矢量容量(而不是一次又一次地重复分配/释放一次矢量256次......)快2.45倍:)

我们可以注意到,time1从numIter = 1to到几乎是恒定的numIter = 256,这意味着分配一个8GB的大向量与分配256个32MB的向量一样昂贵.但是,分配一个8GB的大向量肯定比分配一个32MB的向量更昂贵,因此重用向量的容量可以提高性能.

从numIter = 512(mem(v)= 16MB)到numIter = 8M(mem(v)= 1kB)是最佳点:两种方法都与numIter和vecSize的所有其他组合一样快,速度更快.这可能与我的处理器的L3缓存大小为8MB的事实有关,因此向量几乎完全适合缓存.我没有真正解释为什么突然跳转time1是为了mem(v)= 16MB,当mem(v)= 8MB时,它似乎更合乎逻辑.请注意,令人惊讶的是,在这个最佳位置,重新使用容量实际上稍快一点!我真的不解释这个.

当numIter > 8M事情开始变得难看.两种方法都变慢,但按值返回矢量变得更慢.在最坏的情况下,使用仅包含一个单一的向量int,重用容量而不是按值返回的速度要快3.3倍.据推测,这是由于malloc()的固定成本开始占主导地位.

注意time2的曲线如何比time1的曲线更平滑:不仅重复使用矢量容量通常更快,但更重要的是,它更可预测.

另外请注意,在最佳位置,我们能够在约0.5秒内执行20亿次64位整数,这在4.2Ghz 64位处理器上非常理想.我们可以通过并行计算以便使用所有8个核心来做得更好(上面的测试一次只使用一个核心,我通过在监视CPU使用情况时重新运行测试来验证).当mem(v)= 16kB时,达到最佳性能,这是L1高速缓存的数量级(i7-7700K的L1数据高速缓存是4x32kB).

当然,差异变得越来越不相关,您实际需要对数据进行的计算越多.如果我们替换sum = std::accumulate(v.begin(), v.end(), sum);为以下结果for (int k : v) sum += std::sqrt(2.0*k);:

结论

1. 使用输出参数而不是按值返回可以通过重用容量来提高性能.
2. 在现代台式计算机上,这似乎仅适用于大矢量(> 16MB)和小矢量(<1kB).
3. 避免分配数百万/数十亿的小矢量(<1kB).如果可能,重新使用容量,或者更好的是,以不同的方式设计您的架构.

其他平台的结果可能不同.像往常一样,如果性能很重要,请为您的特定用例编写基准.

Answer 5

我仍然认为这是一个不好的做法,但值得注意的是我的团队使用MSVC 2008和GCC 4.1,所以我们没有使用最新的编译器.

以前,vtune与MSVC 2008中显示的很多热点都归结为字符串复制.我们有这样的代码:

String Something::id() const
{
    return valid() ? m_id: "";
}

...请注意,我们使用了自己的String类型(这是必需的,因为我们提供了一个软件开发工具包,其中插件编写者可能使用不同的编译器,因此std :: string/std :: wstring的不兼容,不兼容的实现).

我做了一个简单的更改,以响应调用图采样分析会话,显示String :: String(const String&)需要花费大量时间.上面示例中的方法是最大的贡献者(实际上,分析会话显示内存分配和释放是最大的热点之一,String复制构造函数是分配的主要贡献者).

我所做的改变很简单:

static String null_string;
const String& Something::id() const
{
    return valid() ? m_id: null_string;
}

然而,这让世界变得与众不同!热点在随后的分析器会话中消失了,除此之外,我们还进行了大量彻底的单元测试,以跟踪我们的应用程序性能.在这些简单的更改后,各种性能测试时间显着下降.

结论:我们没有使用绝对最新的编译器,但我们似乎仍然无法依靠编译器优化复制以便可靠地返回值(至少在所有情况下都不是这样).对于那些使用像MSVC 2010这样的新编译器的人来说情况可能并非如此.我期待我们何时可以使用C++ 0x并简单地使用rvalue引用,而不必担心我们通过返回复杂来使我们的代码变得悲观按价值分类.

[编辑]正如Nate指出的那样,RVO适用于在函数内部创建的返回临时值.在我的情况下,没有这样的临时(除了我们构造一个空字符串的无效分支),因此RVO将不适用.