Download prealloc - Download de código fonte prealloc

prealloc

Outras categorias

1.0.0

Baixar

Prealloc

O pré -realloc é uma ferramenta de análise estática para encontrar declarações de fatias que podem ser potencialmente pré -realocadas.

Instalação

 go install github.com/alexkohler/prealloc@latest

Uso

Semelhante a outras ferramentas de análise estática GO (como Golint, Go Vet), o pré -realloc pode ser invocado com um ou mais nomes de arquivos, diretórios ou pacotes nomeados por seu caminho de importação. O Préalloc também suporta o ... curinga.

 prealloc [flags] files/directories/packages

Bandeiras

-Simple (padrão true) - Relate sugestões de pré -alocação apenas em loops simples que não têm devoluções/quebras/continua/gotase nelas. Definir isso como falso pode aumentar os falsos positivos.
-Rangeloops (padrão true) - Relate sugestões de pré -alocação sobre loops de alcance.
-Forloops (padrão false) - Relate sugestões de pré -alocação sobre loops. Isso é falso por padrão, devido ao fato de que geralmente haverá coisas mais estranhas que estão acontecendo dentro de loops (pelo menos pelo que observei na biblioteca padrão).
-set_exit_status (padrão false) - Defina o status de saída como 1 se algum problema for encontrado.

Propósito

Enquanto o GO tenta evitar a realocação, aumentando a capacidade com antecedência, isso às vezes não é suficiente para fatias mais longas. Se o tamanho de uma fatia for conhecido no momento de sua criação, ela deve ser especificada.

Considere o seguinte benchmark: (Isso pode ser encontrado em pré -realloc_test.go neste repositório)

 import "testing"

func BenchmarkNoPreallocate ( b * testing. B ) {
	existing := make ([] int64 , 10 , 10 )
	b . ResetTimer ()
	for i := 0 ; i < b . N ; i ++ {
		// Don't preallocate our initial slice
		var init [] int64
		for _ , element := range existing {
			init = append ( init , element )
		}
	}
}

func BenchmarkPreallocate ( b * testing. B ) {
	existing := make ([] int64 , 10 , 10 )
	b . ResetTimer ()
	for i := 0 ; i < b . N ; i ++ {
		// Preallocate our initial slice
		init := make ([] int64 , 0 , len ( existing ))
		for _ , element := range existing {
			init = append ( init , element )
		}
	}
}

$ go test -bench=. -benchmem
goos: linux
goarch: amd64
BenchmarkNoPreallocate-4   	 3000000	       510 ns/op	     248 B/op	       5 allocs/op
BenchmarkPreallocate-4     	20000000	       111 ns/op	      80 B/op	       1 allocs/op

Como você pode ver, não pré -realizar pode causar um atingido de desempenho, principalmente devido a ter que realocar a matriz subjacente. O padrão comparado acima é comum no GO: Declare uma fatia e, em seguida, escreva algum tipo de alcance ou para o loop que anexa ou indexa nele. O objetivo desta ferramenta é sinalizar declarações de fatia/loop como a do BenchmarkNoPreallocate .

Exemplo

Alguns exemplos da fonte Go 1.9.2:

$ prealloc go/src/....
archive/tar/reader_test.go:854 Consider preallocating ss
archive/zip/zip_test.go:201 Consider preallocating all
cmd/api/goapi.go:301 Consider preallocating missing
cmd/api/goapi.go:476 Consider preallocating files
cmd/asm/internal/asm/endtoend_test.go:345 Consider preallocating extra
cmd/cgo/main.go:60 Consider preallocating ks
cmd/cgo/ast.go:149 Consider preallocating pieces
cmd/compile/internal/ssa/flagalloc.go:64 Consider preallocating oldSched
cmd/compile/internal/ssa/regalloc.go:719 Consider preallocating phis
cmd/compile/internal/ssa/regalloc.go:718 Consider preallocating oldSched
cmd/compile/internal/ssa/regalloc.go:1674 Consider preallocating oldSched
cmd/compile/internal/ssa/gen/rulegen.go:145 Consider preallocating ops
cmd/compile/internal/ssa/gen/rulegen.go:145 Consider preallocating ops
cmd/dist/build.go:893 Consider preallocating all
cmd/dist/build.go:1246 Consider preallocating plats
cmd/dist/build.go:1264 Consider preallocating results
cmd/dist/buildgo.go:59 Consider preallocating list
cmd/doc/pkg.go:363 Consider preallocating names
cmd/fix/typecheck.go:219 Consider preallocating b
cmd/go/internal/base/path.go:34 Consider preallocating out
cmd/go/internal/get/get.go:175 Consider preallocating out
cmd/go/internal/load/pkg.go:1894 Consider preallocating dirent
cmd/go/internal/work/build.go:2402 Consider preallocating absOfiles
cmd/go/internal/work/build.go:2731 Consider preallocating absOfiles
cmd/internal/objfile/pe.go:48 Consider preallocating syms
cmd/internal/objfile/pe.go:38 Consider preallocating addrs
cmd/internal/objfile/goobj.go:43 Consider preallocating syms
cmd/internal/objfile/elf.go:35 Consider preallocating syms
cmd/link/internal/ld/lib.go:1070 Consider preallocating argv
cmd/vet/all/main.go:91 Consider preallocating pp
database/sql/sql.go:66 Consider preallocating list
debug/macho/file.go:506 Consider preallocating all
internal/trace/order.go:55 Consider preallocating batches
mime/quotedprintable/reader_test.go:191 Consider preallocating outcomes
net/dnsclient_unix_test.go:954 Consider preallocating confLines
net/interface_solaris.go:85 Consider preallocating ifat
net/interface_linux_test.go:91 Consider preallocating ifmat4
net/interface_linux_test.go:100 Consider preallocating ifmat6
net/internal/socktest/switch.go:34 Consider preallocating st
os/os_windows_test.go:766 Consider preallocating args
runtime/pprof/internal/profile/filter.go:77 Consider preallocating lines
runtime/pprof/internal/profile/profile.go:554 Consider preallocating names
text/template/parse/node.go:189 Consider preallocating decl

 // cmd/api/goapi.go:301
var missing [] string
for feature := range optionalSet {
	missing = append ( missing , feature )
}

// cmd/fix/typecheck.go:219
var b []ast. Expr
for _ , x := range a {
	b = append ( b , x )
}

// net/internal/socktest/switch.go:34
var st [] Stat
sw . smu . RLock ()
for _ , s := range sw . stats {
	ns := * s
	st = append ( st , ns )
}
sw . smu . RUnlock ()

// cmd/api/goapi.go:301
var missing [] string
for feature := range optionalSet {
	missing = append ( missing , feature )
}

Mesmo que o tamanho que a fatia esteja sendo pré -alocado seja pequeno, ainda há um ganho de desempenho em especificar explicitamente a capacidade, em vez de deixá -lo para append que ele precisa pré -alocar. Obviamente, a pré -allocação não precisa ser feita em todos os lugares . O trabalho dessa ferramenta é apenas ajudar a sugerir lugares onde se deve considerar pré -alocada.

Como faço para corrigir as sugestões do pré -alloc?

Durante a declaração da sua fatia, em vez de usar o valor zero da fatia com var , inicialize com a função de make embutida de Go, passando o tipo e o comprimento apropriados. Esse comprimento geralmente será o que você está variando. Corrigir os exemplos de cima seria assim:

 // cmd/api/goapi.go:301
missing := make ([] string , 0 , len ( optionalSet ))
for feature := range optionalSet {
	missing = append ( missing , feature )
}

// cmd/fix/typecheck.go:219
b := make ([]ast. Expr , 0 , len ( a ))
for _ , x := range a {
	b = append ( b , x )
}

// net/internal/socktest/switch.go:34
st := make ([] Stat , 0 , len ( sw . stats ))
sw . smu . RLock ()
for _ , s := range sw . stats {
	ns := * s
	st = append ( st , ns )
}
sw . smu . RUnlock ()

// cmd/api/goapi.go:301
missing := make ([] string , 0 , len ( optionalSet ))
for feature := range optionalSet {
	missing = append ( missing , feature )
}

Nota: Se o desempenho for absolutamente crítico, pode ser mais eficiente usar copy em vez de append fatias maiores. Para referência, consulte o seguinte benchmark:

 func BenchmarkSize200PreallocateCopy ( b * testing. B ) {
	existing := make ([] int64 , 200 , 200 )
	b . ResetTimer ()
	for i := 0 ; i < b . N ; i ++ {
		// Preallocate our initial slice
		init := make ([] int64 , len ( existing ))
		copy ( init , existing )
	}
}

 $ go test -bench=. -benchmem
goos: linux
goarch: amd64
BenchmarkSize200NoPreallocate-4     	  500000	      3080 ns/op	    4088 B/op	       9 allocs/op
BenchmarkSize200Preallocate-4       	 1000000	      1163 ns/op	    1792 B/op	       1 allocs/op
BenchmarkSize200PreallocateCopy-4   	 2000000	       807 ns/op	    1792 B/op	       1 allocs/op

PENDÊNCIA

Configuração sobre se deve ou não ser executado em arquivos de teste
Suporte para IFS incorporado (atualmente, o pré -alloc encontrará apenas quebras/retornos/continua/gotos se estiverem em um único bloco, eu gostaria de expandir isso para apoiar múltiplos blocos se no futuro).
Suporte global (por exemplo, pré -alloc *.go)