Pertanyaan Apakah switch jenis pernyataan / jenis memiliki kinerja buruk / lambat di Go?


Seberapa lambat penggunaan tipe pernyataan / sakelar tipe di Go, sebagai metode pencarian tipe run-time?

Saya pernah mendengar bahwa di C / C ++ misalnya, menemukan jenis pada saat run time memiliki kinerja yang buruk. Untuk memintas itu, Anda biasanya menambahkan jenis anggota ke kelas, jadi Anda dapat membandingkannya dengan ini daripada mentransmisi.

Saya belum menemukan jawaban yang jelas untuk ini sepanjang www.

Inilah contoh yang saya tanyakan - Apakah ini dipertimbangkan cepat bila dibandingkan dengan metodologi pemeriksaan jenis lainnya (seperti yang disebutkan di atas, atau yang lain yang tidak saya ketahui)?

func question(anything interface{}) {
    switch v := anything.(type) {
        case string:
            fmt.Println(v)
        case int32, int64:
            fmt.Println(v)
        case SomeCustomType:
            fmt.Println(v)
        default:
            fmt.Println("unknown")
    }
}

32
2018-01-19 12:39


asal


Jawaban:


Sangat mudah untuk menulis tes Benchmark untuk memeriksanya: http://play.golang.org/p/E9H_4K2J9-

package main

import (
    "testing"
)

type myint int64

type Inccer interface {
    inc()
}

func (i *myint) inc() {
    *i = *i + 1
}

func BenchmarkIntmethod(b *testing.B) {
    i := new(myint)
    incnIntmethod(i, b.N)
}

func BenchmarkInterface(b *testing.B) {
    i := new(myint)
    incnInterface(i, b.N)
}

func BenchmarkTypeSwitch(b *testing.B) {
    i := new(myint)
    incnSwitch(i, b.N)
}

func BenchmarkTypeAssertion(b *testing.B) {
    i := new(myint)
    incnAssertion(i, b.N)
}

func incnIntmethod(i *myint, n int) {
    for k := 0; k < n; k++ {
        i.inc()
    }
}

func incnInterface(any Inccer, n int) {
    for k := 0; k < n; k++ {
        any.inc()
    }
}

func incnSwitch(any Inccer, n int) {
    for k := 0; k < n; k++ {
        switch v := any.(type) {
        case *myint:
            v.inc()
        }
    }
}

func incnAssertion(any Inccer, n int) {
    for k := 0; k < n; k++ {
        if newint, ok := any.(*myint); ok {
            newint.inc()
        }
    }
}

Pada mesin amd64 saya, saya mendapatkan waktu berikut:

$ go test -bench=.
BenchmarkIntmethod  1000000000           2.71 ns/op
BenchmarkInterface  1000000000           2.98 ns/op
BenchmarkTypeSwitch 100000000           16.7 ns/op
BenchmarkTypeAssertion  100000000       13.8 ns/op

Jadi sepertinya mengakses metode melalui switch tipe atau pernyataan tipe adalah sekitar 5-6 kali lebih lambat daripada memanggil metode secara langsung atau melalui antarmuka.

Saya tidak tahu apakah C ++ lebih lambat atau jika pelambatan ini dapat ditoleransi untuk aplikasi Anda.


27
2018-01-19 15:21



Saya ingin memverifikasi jawaban siritinga sendiri, dan memeriksa apakah menghapus cek dalam TypeAssertion akan membuatnya lebih cepat. Saya menambahkan hal berikut dalam tolok ukur mereka:

func incnAssertionNoCheck(any Inccer, n int) {
    for k := 0; k < n; k++ {
        any.(*myint).inc()
    }
}

func BenchmarkTypeAssertionNoCheck(b *testing.B) {
    i := new(myint)
    incnAssertionNoCheck(i, b.N)
}

dan menjalankan kembali tolok ukur di mesin saya.

BenchmarkIntmethod-12               2000000000           1.77 ns/op
BenchmarkInterface-12               1000000000           2.30 ns/op
BenchmarkTypeSwitch-12              500000000            3.76 ns/op
BenchmarkTypeAssertion-12           2000000000           1.73 ns/op
BenchmarkTypeAssertionNoCheck-12    2000000000           1.72 ns/op

Jadi sepertinya biaya melakukan switch jenis turun secara signifikan dari Go 1.4 (yang saya anggap siritinga digunakan) untuk Go 1.6 (yang saya gunakan): 5-6 kali lebih lambat hingga kurang dari 2 kali lebih lambat untuk sakelar tipe, dan tidak ada perlambatan untuk jenis pernyataan (dengan atau tanpa pemeriksaan).


10
2017-07-07 12:18



Saya menjalankan contoh bangku dengan @siritinga di laptop saya (go1.7.3 linux / amd64), dapatkan hasil ini:

$ go test -bench .
BenchmarkIntmethod-4            2000000000               1.99 ns/op
BenchmarkInterface-4            1000000000               2.30 ns/op
BenchmarkTypeSwitch-4           2000000000               1.80 ns/op
BenchmarkTypeAssertion-4        2000000000               1.67 ns/op

3
2018-01-19 08:33



Hasil Saya menggunakan Go 1.9

BenchmarkIntmethod-4                1000000000           2.42 ns/op
BenchmarkInterface-4                1000000000           2.84 ns/op
BenchmarkTypeSwitch-4               1000000000           2.29 ns/op
BenchmarkTypeAssertion-4            1000000000           2.14 ns/op
BenchmarkTypeAssertionNoCheck-4     1000000000           2.34 ns/op

Ketegasan Jenis sekarang jauh lebih cepat, tetapi penghapusan yang paling menarik dari pemeriksaan jenis membuatnya lambat.


3
2017-09-02 14:51



Di dalam Anda

switch v := anything.(type) {
    case SomeCustomType:
        fmt.Println(v)
...

jika tidak perlu SomeCustomType.Fields atau metode seperti di fmt.Println(v), lakukan

switch anything.(type) { //avoid 'v:= ' interface conversion, only assertion
    case SomeCustomType:
        fmt.Println("anything type is SomeCustomType", anything)
...

harus sekitar dua kali lebih cepat


1
2018-01-19 18:56



TL; DR: itu benar-benar tergantung pada distribusi jenis, tetapi antarmuka adalah pilihan paling aman kecuali Anda yakin bahwa jenis akan muncul dalam potongan reguler. Juga pertimbangkan bahwa jika kode Anda jarang dijalankan, pencetus cabang juga tidak akan menjadi hangat.

Penjelasan panjang:

Di go1.9.2 pada darwin / amd64

BenchmarkIntmethod-4                2000000000           1.67 ns/op
BenchmarkInterface-4                2000000000           1.89 ns/op
BenchmarkTypeSwitch-4               2000000000           1.26 ns/op
BenchmarkTypeAssertion-4            2000000000           1.41 ns/op
BenchmarkTypeAssertionNoCheck-4     2000000000           1.61 ns/op

Hal yang penting untuk dicatat di sini adalah bahwa jenis switch dengan hanya satu cabang bukanlah perbandingan yang sangat adil terhadap penggunaan antarmuka. Prediktor cabang CPU akan menjadi sangat panas, sangat cepat, dan memberikan hasil yang sangat baik. Tanda bangku yang lebih baik akan menggunakan jenis acak pseudo dan antarmuka dengan penerima acak pseudo. Jelas, kita perlu menghapus pengiriman metode statis dan tetap hanya antarmuka versus typeswitch (tipe pernyataan juga menjadi kurang bermakna karena akan membutuhkan banyak jika pernyataan, dan tidak ada yang akan menulis itu daripada menggunakan saklar tipe). Berikut ini kodenya:

package main

import (
        "testing"
)

type myint0 int64
type myint1 int64
type myint2 int64
type myint3 int64
type myint4 int64
type myint5 int64
type myint6 int64
type myint7 int64
type myint8 int64
type myint9 int64

type DoStuff interface {
        doStuff()
}

func (i myint0) doStuff() {
        i += 0
}

func (i myint1) doStuff() {
        i += 1
}

func (i myint2) doStuff() {
        i += 2
}

func (i myint3) doStuff() {
        i += 3
}

func (i myint4) doStuff() {
        i += 4
}

func (i myint5) doStuff() {
        i += 5
}

func (i myint6) doStuff() {
        i += 6
}

func (i myint7) doStuff() {
        i += 7
}

func (i myint8) doStuff() {
        i += 8
}

func (i myint9) doStuff() {
        i += 9
}

// Randomly generated
var input []DoStuff = []DoStuff{myint0(0), myint1(0), myint1(0), myint5(0), myint6(0), myint7(0), myint6(0), myint9(0), myint7(0), myint7(0), myint6(0), myint2(0), myint9(0), myint0(0), myint2(0), myint3(0), myint5(0), myint1(0), myint4(0), myint0(0), myi
nt4(0), myint3(0), myint9(0), myint3(0), myint9(0), myint5(0), myint0(0), myint0(0), myint8(0), myint1(0)}

func BenchmarkInterface(b *testing.B) {
        doStuffInterface(b.N)
}

func BenchmarkTypeSwitch(b *testing.B) {
        doStuffSwitch(b.N)
}

func doStuffInterface(n int) {
        for k := 0; k < n; k++ {
                for _, in := range input {
                        in.doStuff()
                }
        }
}

func doStuffSwitch(n int) {
        for k := 0; k < n; k++ {
                for _, in := range input {
                        switch v := in.(type) {
                        case *myint0:
                                v.doStuff()
                        case *myint1:
                                v.doStuff()
                        case *myint2:
                                v.doStuff()
                        case *myint3:
                                v.doStuff()
                        case *myint4:
                                v.doStuff()
                        case *myint5:
                                v.doStuff()
                        case *myint6:
                                v.doStuff()
                        case *myint7:
                                v.doStuff()
                        case *myint8:
                                v.doStuff()
                        case *myint9:
                                v.doStuff()
                        }
                }
        }
}

Dan hasilnya:

go test -bench .
goos: darwin
goarch: amd64
pkg: test
BenchmarkInterface-4        20000000            74.0 ns/op
BenchmarkTypeSwitch-4       20000000           119 ns/op
PASS
ok      test    4.067s

Semakin banyak jenis dan semakin acak distribusi, semakin besar antarmuka menang.

Untuk menunjukkan perbedaan ini saya mengubah kode ke tolok ukur pilihan acak versus selalu memilih jenis yang sama. Dalam hal ini, pengalih jenis kembali lebih cepat, sementara antarmuka memiliki kecepatan yang sama, berikut adalah kodenya:

package main

import (
        "testing"
)

type myint0 int64
type myint1 int64
type myint2 int64
type myint3 int64
type myint4 int64
type myint5 int64
type myint6 int64
type myint7 int64
type myint8 int64
type myint9 int64

type DoStuff interface {
        doStuff()
}

func (i myint0) doStuff() {
        i += 0
}

func (i myint1) doStuff() {
        i += 1
}

func (i myint2) doStuff() {
        i += 2
}

func (i myint3) doStuff() {
        i += 3
}

func (i myint4) doStuff() {
        i += 4
}

func (i myint5) doStuff() {
        i += 5
}

func (i myint6) doStuff() {
        i += 6
}

func (i myint7) doStuff() {
        i += 7
}

func (i myint8) doStuff() {
        i += 8
}

func (i myint9) doStuff() {
        i += 9
}

// Randomly generated
var randInput []DoStuff = []DoStuff{myint0(0), myint1(0), myint1(0), myint5(0), myint6(0), myint7(0), myint6(0), myint9(0), myint7(0), myint7(0), myint6(0), myint2(0), myint9(0), myint0(0), myint2(0), myint3(0), myint5(0), myint1(0), myint4(0), myint0(0),
 myint4(0), myint3(0), myint9(0), myint3(0), myint9(0), myint5(0), myint0(0), myint0(0), myint8(0), myint1(0)}

var oneInput []DoStuff = []DoStuff{myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), 
myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0), myint1(0)}

func BenchmarkRandomInterface(b *testing.B) {
        doStuffInterface(randInput, b.N)
}

func BenchmarkRandomTypeSwitch(b *testing.B) {
        doStuffSwitch(randInput, b.N)
}

func BenchmarkOneInterface(b *testing.B) {
        doStuffInterface(oneInput, b.N)
}

func BenchmarkOneTypeSwitch(b *testing.B) {
        doStuffSwitch(oneInput, b.N)
}

func doStuffInterface(input []DoStuff, n int) {
        for k := 0; k < n; k++ {
                for _, in := range input {
                        in.doStuff()
                }
        }
}

func doStuffSwitch(input []DoStuff, n int) {
        for k := 0; k < n; k++ {
                for _, in := range input {
                        switch v := in.(type) {
                        case *myint0:
                                v.doStuff()
                        case *myint1:
                                v.doStuff()
                        case *myint2:
                                v.doStuff()
                        case *myint3:
                                v.doStuff()
                        case *myint4:
                                v.doStuff()
                        case *myint5:
                                v.doStuff()
                        case *myint6:
                                v.doStuff()
                        case *myint7:
                                v.doStuff()
                        case *myint8:
                                v.doStuff()
                        case *myint9:
                                v.doStuff()
                        }
                }
        }
}

Berikut hasilnya:

BenchmarkRandomInterface-4      20000000            76.9 ns/op
BenchmarkRandomTypeSwitch-4     20000000           115 ns/op
BenchmarkOneInterface-4         20000000            76.6 ns/op
BenchmarkOneTypeSwitch-4        20000000            68.1 ns/op

1
2017-12-14 17:10