为什么 std::cout 如此耗时？

Question

我编写了一个程序来计算 8 个字符的字符串“sharjeel”的排列。

#include <iostream>
#include <time.h>

char string[] = "sharjeel";
int len = 8;
int count = 0;

void swap(char& a, char& b){
    char t = a;
    a = b;
    b = t;
}
void permute(int pos) {
    if(pos==len-1){
        std::cout << ++count << "\t" << string << std::endl;
        return;
    }
    else {
        for (int i = pos; i < len;i++)
        {
            swap(string[i], string[pos]);
            permute(pos + 1);
            swap(string[i], string[pos]);
        }
    }
}

int main(){
    clock_t start = clock();
    permute(0);
    std::cout << "Permutations: " << count << std::endl;
    std::cout << "Time taken: " << (double)(clock() - start) / (double)CLOCKS_PER_SEC << std::endl;
    return 1;
}

如果我打印每个排列，执行完成大约需要 9.8 秒。

40314   lshaerej
40315   lshareej
40316   lshareje
40317   lshareej
40318   lshareje
40319   lsharjee
40320   lsharjee
Permutations: 40320
Time taken: 9.815

现在如果我换行：

std::cout << ++count << "\t" << string << std::endl;

用这个：

++count;

然后重新编译，输出为：

Permutations: 40320
Time taken: 0.001

再次运行：

Permutations: 40320
Time taken: 0.002

使用带有 -O3 的 g++ 编译

为什么 std::cout 相对比较耗时？有没有更快的打印方法？

编辑：制作了程序的 C# 版本

/*
 * Permutations
 * in c#
 * much faster than the c++ version 
 */

using System;
using System.Diagnostics;

namespace Permutation_C
{
    class MainClass
    {
        private static uint len;
        private static char[] input;
        private static int count = 0;

        public static void Main (string[] args)
        {
            Console.Write ("Enter a string to permute: ");
            input = Console.ReadLine ().ToCharArray();
            len = Convert.ToUInt32(input.Length);
            Stopwatch clock = Stopwatch.StartNew();
            permute (0u);
            Console.WriteLine("Time Taken: {0} seconds", clock.ElapsedMilliseconds/1000.0);
        }

        static void permute(uint pos)
        {

            if (pos == len - 1u) {
                Console.WriteLine ("{0}.\t{1}",++count, new string(input));
                return;
            } else {
                for (uint i = pos; i < len; i++) {
                    swap (Convert.ToInt32(i),Convert.ToInt32(pos));
                    permute (pos + 1);
                    swap (Convert.ToInt32(i),Convert.ToInt32(pos));
                }
            }

        }
        static void swap(int a, int b) {
            char t = input[a];
            input[a] = input[b];
            input[b] = t;
        }
    }
}

输出：

40313.  lshaerje
40314.  lshaerej
40315.  lshareej
40316.  lshareje
40317.  lshareej
40318.  lshareje
40319.  lsharjee
40320.  lsharjee
Time Taken: 4.628 seconds
Press any key to continue . . .

从这里开始，与 std::cout 的结果相比，Console.WriteLine() 似乎快了近一倍。什么似乎在减慢 std::cout 的速度？

Answer 1

std::cout 最终导致操作系统被调用。

如果您想要快速计算某些东西，您必须确保计算中不涉及任何外部实体，尤其是在编写时考虑到多功能性而非性能的实体，例如操作系统。

想让它跑得更快吗？您有几个选择：

1. 将<< std::endl; 替换为<< '\n'。这将避免在每一行上将 C++ 运行时的内部缓冲区刷新到操作系统。它应该会带来巨大的性能提升。

2. 按照用户 Galik Mar 在评论中的建议使用 std::ios::sync_with_stdio(false);。

3. 在缓冲区中收集尽可能多的传出文本，并通过一次调用一次输出整个缓冲区。

4. 将您的输出写入文件而不是控制台，然后让该文件由单独的应用程序（例如 Notepad++）显示，该应用程序可以跟踪更改并保持滚动到底部。

至于为什么它如此“耗时”，（换句话说，慢，）那是因为std::cout（最终是操作系统的标准输出流）的主要目的是多功能性，而不是性能。想一想：std::cout 是一个 C++ 库函数，它将调用操作系统；操作系统将确定正在写入的文件不是真正的文件，而是控制台，因此它将数据发送到控制台子系统；控制台子系统将接收数据并开始调用图形子系统以在控制台窗口中呈现文本；图形子系统将在光栅显示器上绘制字体字形，在渲染数据时，将滚动控制台窗口，这涉及复制大量的视频 RAM。即使显卡在硬件中处理了部分工作，这也是一项非常繁重的工作。

至于 C# 版本，我不确定到底发生了什么，但可能发生的情况完全不同：在 C# 中，您没有调用 Console.Out.Flush()，因此您的输出被缓存，您不会遭受C++ 的std::cout << std::endl 产生的开销导致每一行都被刷新到操作系统。 但是， 当缓冲区确实变满时，C# 必须将其刷新到操作系统，然后它不仅会受到所代表的开销的影响受操作系统的影响，但也受其虚拟机工作方式固有的强大的托管到本机和本机到托管的转换。