Question

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

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

如果第二个循环被注释掉，第一个循环需要1.5秒。但是，使用第二个循环进行编译会减慢第一个循环，现在需要30-40秒！

换句话说：第二个循环以某种方式减慢了第一个循环。我试图改变范围，更改编译器，更改编译器标志，更改循环本身，将所有内容放入main（），使用boost :: iostream甚至在共享库中放置一个循环，但在每次尝试中都会出现同样的问题！

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

编辑：以下是我的问题的完整示例------------＆gt;

<article class="col-sm-6 grid-tile">

  <div class="textbox-fill">
    
    <div class="about-textbox">
      
      <h2>Some text</h2>
      <p>Some text</p>
      
    </div>
    
  </div>
</article>

我还注意到，降低列数会加快第一次循环。

分析器将手指指向此行：

#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; 
}

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

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

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

Answer 1

我的理论：

分配并触摸所有内存会从磁盘缓存中清除大文件，因此下一次运行必须从磁盘读取它们。

如果你运行没有loop2的版本几次来预热磁盘缓存，那么运行带有 loop2的版本，我预测它会在第一次运行时很快，但如果没有运行速度很慢首先预热磁盘缓存。

读取文件后会发生内存消耗。这导致记忆压力＆＃34;在页面缓存（也称为磁盘缓存）上，导致它从缓存中逐出数据，为您的进程写入页面腾出空间。

您的计算机可能只有足够的可用RAM来缓存您的工作集。关闭您的网络浏览器可能会腾出足够的空间来改变现状！或者不是，因为您的11998151055是11.1GiB，并且您正在编写它的每一页。（每个字节，甚至。你可以用memset来实现更高的性能，尽管我假设你所展示的只是一个虚拟版本）
BTW，调查此问题的另一个工具是time ./a.out。它可以告诉您程序是否将所有CPU时间花费在用户空间与内核（＆＃34;系统＆＃34;）之间。

如果user + sys加起来实时，则您的进程受CPU限制。如果没有，它的I / O绑定，你的进程在磁盘I / O上阻塞（这是正常的，因为计算新行应该很快）。

Answer 2

来自THIS PAGE：

“函数close关闭文件描述符filedes。关闭文件会产生以下后果：

取消分配文件描述符。该进程拥有的任何记录锁都将被解锁。当关闭与管道或FIFO相关的所有文件描述符时，任何未读数据都将被丢弃。“

我认为您可能会在之前的阅读中锁定资源。尝试关闭文件并告诉我们结果。

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

我还注意到，降低列数会加快第一次循环。

2 个答案: