逐行处理花费的时间太长

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《逐行处理花费的时间太长》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

我正在处理一些非常大的文件，而我的简单 go 程序执行此操作需要 2 分钟才能运行，而不是等效 c 程序所需的 15 秒 (https://gist.github.com/g2boojum /5729bf75a41f537b8251af25a816c2fc）。显然我错过了一些重要的事情。 （这也是我的第一个 go 程序，所以我确信代码也很糟糕。）

我正在处理的文件是 csv 文件，如下所示，唯一的问题是它们的大小为 gb。

board;channel;timetag;energy;energyshort;flags
0;0;179096000;316;105;0x0
0;0;682168000;449;146;0x0
0;0;905440000;92;35;0x0

我本来可以使用 csv 模块，但 scanf 将字段转换为对我来说正确的类型，这看起来更简单。代码所做的就是跳过标题行，然后逐行读取文件的其余部分以创建第四个字段的直方图，然后将直方图写入末尾。

import (    
    "bufio"    
    "fmt"    
    "os"     
    "log"    
)    
     
const num_channels int = 4096    
    
func main () {    
    if len(os.args) != 3 {    
        fmt.printf("usage: %s infile outfile\n", os.args[0])    
        os.exit(1)    
    }    
    fin, err := os.open(os.args[1])    
    if err != nil {    
        log.fatal(err)    
    }    
    scanner := bufio.newscanner(fin)               
    scanner.scan() // skip the header line     
    fout, err := os.create(os.args[2])    
    if err != nil {    
        log.fatal(err)    
    }    
    fmt.fprintf(fout, "channel,total\n")    
    var total[num_channels] uint64    
    var tmax int64    
    var board, channel, energy, energyshort, flags int    
    var timetag int64    
    for scanner.scan() {    
        fmt.sscanf(scanner.text(), "%d;%d;%d;%d;%d;%x", &board, &channel, &timetag, &energy, &energyshort, &flags)    
        total[energy] += 1    
        tmax = timetag        
    }                                                                                    
    tmax_s := float64(tmax)/1e12    
    fmt.println("tmax = ", tmax_s)    
    for i, val := range total {         
        fmt.fprintf(fout, "%v,%v\n", i, float64(val)/tmax_s)    
    }    
}

帮忙？谢谢！

[更新、解决方案和一些奇怪的地方]

我简化了事情，这样我就可以更好地了解更简单的代码所发生的事情。我删除了用于测试所有内容的 csv 文件的标题行，并且还创建了一个可以共享的更短版本的 csv 文件，以防有人想要测试用例（https://grantgoodyear.org/files /sample60.csv）。

这是一个简化的 c 代码：

#include 

int main(int argc, char* argv[]) {
  file* fp = fopen(argv[1], "r");
  int board, channel, energy, energyshort, flags;
  long timetag;
  double tmax = 0;
  while ((fscanf(fp, "%d;%d;%ld;%d;%d;%x", &board, &channel, &timetag, &energy, &energyshort, &flags)) != eof) {
    tmax = timetag / 1.0e12;
  }
  printf("tmax: %f\n", tmax);
  fclose(fp);
}

处理短文件和1.5gb文件分别需要0.16秒和15秒。

$ time cmaxt sample60.csv 
tmax: 59.999983

real    0m0.160s
user    0m0.152s
sys 0m0.008s
$ time cmaxt long.csv 
tmax: 7200.265511

real    0m14.730s
user    0m14.451s
sys 0m0.255s

相比之下，这是一个几乎相同的 go 程序：

import (
    "io"
    "fmt"
    "os"
)


func main () {
    fin, _ := os.open(os.args[1])
    var tmax float64
    var board, channel, energy, energyshort, flags int
    var timetag int64
    for {
        _, err := fmt.fscanf(fin,"%d;%d;%d;%d;%d;%x", &board, &channel, &timetag, &energy, &energyshort, &flags)
        if err == io.eof {
            break
        }
        tmax = float64(timetag)/1e12
    }
    fmt.println("tmax = ", tmax)
}

运行时间非常长：

$ time gomaxt sample60.csv 
tmax =  59.999983344

real    0m8.044s
user    0m4.677s
sys 0m3.555s
$ time gomaxt long.csv 
tmax =  7200.265510652

real    18m37.472s
user    10m58.221s
sys 8m28.282s

我不知道这里发生了什么，但它花费的时间比 c 版本长 50-75 倍。特别奇怪的是sys时间这么长。

我更改了 go 版本，使其更像我原来的帖子，使用 bufio.newscanner 和 fmt.sscanf 进行分割：

 import (
    "bufio"
    "fmt"
    "os"
)


func main () {
    fin, _ := os.open(os.args[1])
    scanner := bufio.newscanner(fin)
    var tmax float64
    var timetag int64
    var board, channel, energy, energyshort, flags int
    for scanner.scan() {
        fmt.sscanf(scanner.text(), "%d;%d;%d;%d;%d;%x", &board, &channel, &timetag, &energy, &energyshort, &flags)
        tmax = float64(timetag)/1e12
    }
    fmt.println("tmax = ", tmax)
}

仅此版本（？！）需要比 c 版本长 6 倍的时间：

$ time gomaxtorig sample60.csv 
tmax =  59.999983344

real    0m0.895s
user    0m0.905s
sys 0m0.038s
$ time gomaxtorig long.csv 
tmax =  7200.265510652

real    1m53.030s
user    2m1.039s
sys 0m3.021s

现在让我们用字符串分割替换 fmt.sscanf：

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)


func main () {
    fin, _ := os.open(os.args[1])
    scanner := bufio.newscanner(fin)
    var tmax float64
    var timetag int64
    for scanner.scan() {
        ss := strings.split(scanner.text(), ";")
        timetag, _ = strconv.parseint(ss[2], 10, 64)
        tmax = float64(timetag)/1e12
    }
    fmt.println("tmax = ", tmax)
}

正如所建议的，大部分时间实际上都花在了 fmt.sscanf 上。该版本的时间比 c 版本稍长两倍：

$ time ../gammaprocess_go/maxtsplit sample60.csv 
tmax =  59.999983344

real    0m0.226s
user    0m0.243s
sys 0m0.022s
$ time ../gammaprocess_go/maxtsplit long.csv 
tmax =  7200.265510652

real    0m26.434s
user    0m28.834s
sys 0m1.683s

我确实编写了一个稍微有点 hacky 的版本，强制对 csv 文件的每一行中的其他字段进行字符串转换，只是为了看看这是否有任何区别，并且时间与上述版本基本相同。

因为我使用的是 scanner.text()，所以创建了很多字符串然后被丢弃，并且建议我使用字节而不是字符串。在我看来，这就是 csv 包的作用，所以我只是使用它：

import (
    "encoding/csv"
    "fmt"
    "os"
    "io"
    "strconv"
)


func main () {
    fin, _ := os.open(os.args[1])
    r := csv.newreader(fin)
    r.comma = ';'

    var tmax float64
    var timetag int64
    for {
        rec, err := r.read()
        if err == io.eof {
            break
        }
        timetag, _ = strconv.parseint(rec[2], 10, 64)
        tmax = float64(timetag)/1e12
    }
    fmt.println("tmax = ", tmax)
}

时间比 scanner.text*() 的字符串分割版本稍长：

$ time gomaxtcsv sample60.csv 
tmax =  59.999983344

real    0m0.281s
user    0m0.300s
sys 0m0.019s
$ time gomaxtcsv long.csv 
tmax =  7200.265510652

real    0m32.736s
user    0m35.619s
sys 0m1.702s

但可能有更多的开销，因为 csv 包所做的事情比我的简单示例要多得多，所以我想说这是不确定的。

无论如何，我可以接受 2 倍的低效率，所以我不会尝试继续优化它。非常感谢回答这个问题的人。

[另一更新]

或者直接查看 2014 年的 https://groups.google.com/g/golang-nuts/c/w08rfbchkbc/m/oirdqcbxka4j。

正确答案

sscanf 占用了大部分时间。做：

ss := strings.Split(scanner.Text(), ";")
        board, _ = strconv.Atoi(ss[0])
        channel, _ = strconv.Atoi(ss[1])
        timetag, _ = strconv.Atoi(ss[2])
        energy, _ = strconv.Atoi(ss[3])
        flags, _ = strconv.ParseUint(ss[4], 16, 64)

省略检查错误。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《逐行处理花费的时间太长》文章吧，也可关注golang学习网公众号了解相关技术文章。