c++ - 一个单独的循环减慢了一个独立的早期循环？

Question

一个单独的循环如何影响一个独立的早期循环的性能？

我的第一个循环读取一些大文本文件并计算行数。在 malloc 之后，第二个循环填充分配的矩阵。

如果第二个循环被注释掉，第一个循环需要 1.5 秒。然而，用第二个循环编译会减慢第一个循环，现在需要 30-40 秒!

换句话说:第二个循环以某种方式减慢了第一个循环。我曾尝试更改范围、更改编译器、更改编译器标志、更改循环本身、将所有内容放入 main()、使用 boost::iostream 甚至将一个循环放在共享库中，但每次尝试都存在相同的问题!

第一个循环很快，直到程序用第二个循环编译。

---

编辑:这是我的问题的完整示例------------>

#include <iostream>
#include <vector>
#include "string.h"
#include "boost/chrono.hpp"
#include "sys/mman.h"
#include "sys/stat.h"
#include "fcntl.h"
#include <algorithm>

unsigned long int countLines(char const *fname) {
    static const auto BUFFER_SIZE = 16*1024;
    int fd = open(fname, O_RDONLY);
    if(fd == -1) {
        std::cout << "Open Error" << std::endl;
        std::exit(EXIT_FAILURE);
    }

    posix_fadvise(fd, 0, 0, 1); 
    char buf[BUFFER_SIZE + 1];
    unsigned long int lines = 0;

    while(size_t bytes_read = read(fd, buf, BUFFER_SIZE)) {
        if(bytes_read == (size_t)-1) {
            std::cout << "Read Failed" << std::endl;
            std::exit(EXIT_FAILURE);
        }
        if (!bytes_read)
            break;

        int n;
        char *p;
        for(p = buf, n=bytes_read ; n > 0 && (p = (char*) memchr(p, '\n', n)) ; n = (buf+bytes_read) - ++p)
            ++lines;
    }
    close(fd);
    return lines;
}

int main(int argc, char *argv[])
{
    // initial variables
    int offset = 55;  
    unsigned long int rows = 0;
    unsigned long int cols = 0;
    std::vector<unsigned long int> dbRows = {0, 0, 0};
    std::vector<std::string> files = {"DATA/test/file1.csv",  // large files: 3Gb 
                                      "DATA/test/file2.csv",  // each line is 55 chars long 
                                      "DATA/test/file3.csv"};

    // find each file's number of rows 
    for (int x = 0; x < files.size(); x++) {   // <--- FIRST LOOP **
        dbRows[x] = countLines(files[x].c_str());
    }

    // define matrix row as being the largest row found 
    // define matrix col as being 55 chars long for each csv file
    std::vector<unsigned long int>::iterator maxCount;
    maxCount = std::max_element(dbRows.begin(), dbRows.end());
    rows = dbRows[std::distance(dbRows.begin(), maxCount)];   // typically rows = 72716067
    cols = dbRows.size() * offset;                            //           cols = 165 

    // malloc required space (11998151055)
    char *syncData = (char *)malloc(rows*cols*sizeof(char));

    // fill up allocated memory with a test letter
    char t[]= "x";
    for (unsigned long int x = 0; x < (rows*cols); x++) {   // <--- SECOND LOOP **
        syncData[x] = t[0];
    } 

    free(syncData);
    return 0; 
}

我还注意到，减少列数可以加快第一个循环的速度。

探查器将手指指向这条线:

while(size_t bytes_read = read(fd, buf, BUFFER_SIZE))

程序在此行空闲 30 秒或等待 230,000 次。在汇编中，等待计数发生在:

Block 5:
lea 0x8(%rsp), %rsi
mov %r12d, %edi
mov $0x4000, %edx
callq  0x402fc0     <------ stalls on callq
Block 6:
mov %rax, %rbx
test %rbx, %rbx
jz 0x404480 <Block 18>

我的猜测是从流中读取时出现 API 阻塞，但我不知道为什么？

Answer 1

我的理论:

分配和接触所有内存会将大文件从磁盘缓存中逐出，因此下一次运行必须从磁盘中读取它们。

如果你运行了几次没有 loop2 的版本来预热磁盘缓存，然后运行一个 有 loop2 的版本，我预计它第一次会很快，但如果没有首先再次预热磁盘缓存。

内存消耗发生在文件被读取之后。这会导致页面缓存(也称为磁盘缓存)出现“内存压力”，从而导致它从缓存中逐出数据以为进程写入页面腾出空间。

您的计算机可能只有勉强可用的 RAM 来缓存您的工作集。关闭您的网络浏览器可能会释放足够的空间来有所作为!或者不是，因为您的 11998151055 是 11.1GiB，并且您正在编写它的每一页。 (甚至每个字节。您可以使用 memset 来实现更高的性能，尽管我假设您所展示的只是一个虚拟版本)

---

顺便说一句，另一个调查这个的工具是time ./a.out。它可以显示您的程序是否将所有 CPU 时间都花在了用户空间与内核(“系统”)时间上。

如果 user+sys 相加为实时，则您的进程受 CPU 限制。如果不是，它是 I/O 绑定(bind)，并且您的进程在磁盘 I/O 上阻塞(这是正常的，因为计算换行符应该很快)。