Mengapa membaca dan menulis fail dalam Go jauh lebih perlahan daripada Perl?

Mengapa membaca dan menulis fail dalam Go jauh lebih perlahan daripada Perl? Ini adalah masalah biasa yang dihadapi oleh ramai pembangun apabila menggunakan kedua-dua bahasa pengaturcaraan ini. Dalam artikel ini, editor PHP Strawberry akan menjawab soalan ini untuk anda. Apabila membandingkan kelajuan membaca dan menulis fail antara Go dan Perl, kita perlu mempertimbangkan dua faktor utama: ciri bahasa dan pelaksanaan asas. Falsafah reka bentuk bahasa Go dari segi membaca dan menulis fail adalah berbeza daripada Perl, yang membawa kepada perbezaan dalam prestasi. Pada masa yang sama, pelaksanaan asas juga merupakan faktor penting yang mempengaruhi kelajuan membaca dan menulis. Seterusnya, kami akan menganalisis faktor ini secara terperinci untuk membantu anda memahami dengan lebih baik mengapa membaca dan menulis fail dalam Go adalah lebih perlahan daripada Perl.

Kandungan soalan

Saya menggunakan go untuk meningkatkan kecekapan kod, tetapi apabila saya menggunakan go untuk membaca dan menulis fail, saya mendapati kecekapan membaca dan menulisnya tidak setinggi perl. Adakah masalah dengan kod saya atau sebab lain?

Bina fail input:

# input file:
for i in $(seq 1 600000) do     echo server$((random%800+100)),$random,$random,$random >> sample.csv done

Baca dan tulis fail menggunakan perl:

time cat sample.csv | perl -ne 'chomp;print"$_"' > out.txt

real    0m0.249s
user    0m0.083s
sys 0m0.049s

Gunakan pergi untuk membaca dan menulis fail:

package main

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

func main() {

    filepath := "./sample.csv"
    file, err := os.openfile(filepath, os.o_rdwr, 0666)
    if err != nil {
        fmt.println("open file error!", err)
        return
    }
    defer file.close()
    buf := bufio.newreader(file)
    for {
        line, err := buf.readstring('\n')
        line = strings.trimspace(line)
        fmt.println(line)
        if err != nil {
            if err == io.eof {
                fmt.println("file read ok!")
                break
            } else {
                fmt.println("read file error!", err)
                return
            }
        }
    }
}

Kemudian saya berlari:

time go run read.go > out.txt

real    0m2.332s
user    0m0.326s
sys 0m2.038s

Mengapa kelajuan membaca dan menulis go hampir 10 kali lebih perlahan daripada perl?

Penyelesaian

Anda membandingkan epal dengan oren.

Terdapat sekurang-kurangnya dua ralat kaedah:

1. Tindakan perl anda mengukur cat 如何读取文件并通过 pipe(2) 发送其内容，而 perl membaca data dari sana, memprosesnya dan menulis hasilnya kepada output standardnya.

2. Ejaan Pergi Anda

   • Ukur proses binaan lengkap rantai alat go (termasuk menyusun, memaut dan menulis fail imej boleh laku) Kemudian jalankan komponen program yang disusun, dan
   • Mengukur tulisan tidak penimbal kepada stdout (fmt.print* panggilan), manakala menulis kepada stdout dalam kod perl - memetik docs - "Jika output adalah ke terminal, penimbalan talian biasanya boleh dilakukan, jika tidak, penimbalan sekat adalah mungkin."
Mari cuba bandingkan epal dengan epal.

Pertama, berikut ialah pelaksanaan go yang serupa:

package main

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

func main() {
    in := bufio.newscanner(os.stdin)
    out := bufio.newwriter(os.stdout)

    for in.scan() {
        s := bytes.trimspace(in.bytes())

        if _, err := out.write(s); err != nil {
            fmt.fprint(os.stderr, "failed to write file:", err)
            os.exit(1)
        }
    }

    if err := out.flush(); err != nil {
        fmt.fprint(os.stderr, "failed to write file:", err)
        os.exit(1)
    }

    if err := in.err(); err != nil {
        fmt.fprint(os.stderr, "reading failed:", err)
        os.exit(1)
    }
}

Mari simpan sebagai

dan ukurnya:

chomp.go

Kod binaan:

1. $ go build chomp.go

Jana fail input:

2. $ for i in $(seq 1 600000);执行 echo server$((random%800+100)),$random,$random,$random;完成 >sample.csv

Jalankan kod perl:

3. $ time { perl -ne 'chomp; print "$_";' <sample.csv >out1.txt; }
   
   real    0m0.226s
   user    0m0.102s
   sys 0m0.048s

Jalankannya sekali lagi untuk memastikan ia telah membaca fail input daripada cache sistem fail:

4. $ time { perl -ne 'chomp; print "$_";' <sample.csv >out1.txt; }
   
   real   0m0.123s
   user   0m0.090s
   sys    0m0.033s

   Perhatikan bagaimana masa pelaksanaan dikurangkan.

Jalankan kod go pada input cache:

5. $ time { ./chomp <sample.csv >out2.txt; }
   
   real   0m0.063s
   user   0m0.032s
   sys    0m0.032s

   Pastikan hasilnya sama:

6. $ cmp out1.txt out2.txt

Seperti yang anda lihat, pada sistem saya dengan SSD, hasilnya adalah lebih kurang sama.

linux/amd64Nah, saya juga harus menunjukkan bahawa untuk mendapatkan hasil yang munasabah anda perlu menjalankan setiap arahan katakan 1000 kali dan purata keputusan dalam setiap kumpulan dan kemudian membandingkan nombor, tetapi saya fikir ini sudah cukup untuk membuktikan apa yang anda Masalah dengan kaedah ialah.

Satu lagi perkara yang perlu dipertimbangkan: masa jalan kedua-dua program ini sangat didominasi oleh sistem fail i/o, jadi jika anda fikir pergi akan lebih pantas, jangkaan anda tidak berasas: kedua-dua program ini adalah Sebahagian daripada masa

tidur

dalam kernel panggilan sistem baca(2) dan tulis(2). Program go mungkin lebih pantas daripada program perl dalam beberapa kes yang melibatkan operasi cpu (terutamanya jika ia ditulis untuk memanfaatkan sistem berbilang teras), tetapi itu tidak berlaku sama sekali dengan contoh anda. read(2) 和 write(2) Oh, hanya untuk menjelaskan fakta yang tidak dinyatakan: manakala spesifikasi bahasa go tidak menyatakan

aot

, dan go run ialah penggodaman untuk pertunjukan sekali sahaja, bukan kerja serius, Ia juga tidak melaksanakan kod apa-apa kerumitan yang serius. Ringkasnya, go-that-you-are-using bukanlah bahasa yang ditafsirkan, walaupun ketersediaan go run mungkin menjadikannya kelihatan begitu. Sebenarnya, ia melakukan apa yang biasa go build akan lakukan, dan kemudian menjalankan boleh laku yang terhasil dan kemudian membuangnya. go run 是一种针对一次性一次性演出的 hack，不严肃的工作，也不执行任何严重复杂程度的代码。简而言之，go-that-you-are-using 并不是一种解释性语言，尽管 go run 的可用性可能使它看起来如此。事实上，它执行正常 go build

Anda mungkin tergoda untuk mengatakan bahawa perl juga mengendalikan "kod sumber", tetapi penterjemah perl sangat dioptimumkan untuk mengendalikan skrip dan rantai alat binaan go - walaupun sangat pantas berbanding kebanyakan bahasa yang disusun lain - tidak direka untuk This is dioptimumkan.
Mungkin perbezaan yang lebih jelas ialah penterjemah perl sebenarnya mentafsirskrip anda (sangat mudah), sedangkan chomp 和 print 是所谓的“内置函数”，很容易提供给由解释器执行脚本。与构建 go 程序相比，编译器解析源代码文件并将其转换为机器代码，链接器实际上读取 go 标准库的编译包的文件 - 所有这些都是 imported， - 从它们，组合所有这些机器代码并写出一个可执行图像文件（这很像 perl binari itu sendiri! ); sudah tentu, ini adalah proses yang sangat memakan sumber dan tiada kaitan dengan pelaksanaan program sebenar.

Atas ialah kandungan terperinci Mengapa membaca dan menulis fail dalam Go jauh lebih perlahan daripada Perl?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!