Téléchargement de prealloc - Téléchargement du code source prealloc

prealloc

Autres catégories

1.0.0

Télécharger

préalque

Prealloc est un outil d'analyse statique GO pour trouver des déclarations de tranche qui pourraient potentiellement être prélorée.

Installation

 go install github.com/alexkohler/prealloc@latest

Usage

Semblable aux autres outils d'analyse statique GO (tels que Golint, GO Vet), Preallloc peut être invoqué avec un ou plusieurs noms de fichiers, répertoires ou packages nommés par son chemin d'importation. Prealloc soutient également le ... Wildcard.

 prealloc [flags] files/directories/packages

Drapeaux

-Simple (par défaut True) - Rapport Suggestions de préallocation uniquement sur des boucles simples qui n'ont aucun retour / pause / continue / gotos. Le réglage sur False peut augmenter les faux positifs.
-RangeLoops (par défaut True) - Rapport Suggestions de préallocation sur les boucles de plage.
-ForLoops (par défaut false) - Rapport Suggestions de préallocation sur les boucles. Ceci est faux par défaut, car il y a généralement des choses plus étranges qui se passent à l'intérieur pour des boucles (du moins à partir de ce que j'ai observé dans la bibliothèque standard).
-set_exit_status (par défaut false) - Définissez l'état de sortie sur 1 si des problèmes sont trouvés.

But

Bien que le GO tente d'éviter la réallocation en augmentant la capacité à l'avance, cela ne suffit parfois pas pour des tranches plus longues. Si la taille d'une tranche est connue au moment de sa création, elle doit être spécifiée.

Considérez la référence suivante: (Cela peut être trouvé dans prealloc_test.go dans ce repo)

 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

Comme vous pouvez le voir, le non-préallocation peut provoquer un coup de performance, principalement dû à la réaffectation du tableau sous-jacent. Le motif benché ci-dessus est courant dans Go: déclarez une tranche, puis écrivez une sorte de plage ou pour une boucle qui y ajout ou les index. Le but de cet outil est de signaler les déclarations de tranche / boucle comme celle de BenchmarkNoPreallocate .

Exemple

Quelques exemples de la Source de 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 )
}

Même si la taille à laquelle la tranche est préalée est petite, il y a encore un gain de performance à avoir pour spécifier explicitement la capacité plutôt que de le append pour découvrir qu'il doit préaller. Bien sûr, la préallocation n'a pas besoin d'être fait partout . Le travail de cet outil est simplement d'aider à suggérer des endroits où l'on devrait envisager de préaller.

Comment corriger les suggestions de Prealloc?

Pendant la déclaration de votre tranche, plutôt que d'utiliser la valeur zéro de la tranche avec var , initialisez-la avec la fonction make de Go, passant le type et la longueur appropriés. Cette longueur sera généralement ce que vous allez. La réparation des exemples d'en haut serait ainsi:

 // 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 )
}

Remarque: Si les performances sont absolument essentielles, il peut être plus efficace d'utiliser copy au lieu append pour des tranches plus grandes. Pour référence, voir la référence suivante:

 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

FAIRE

Configuration sur l'opportunité d'exécuter ou non sur les fichiers de test
Prise en charge des IF intégrés (Actuellement, Preallloc ne trouvera que des pauses / retours / continues / gotos s'ils sont dans un seul bloc si je voudrais développer cela à la prise en charge de plusieurs blocs sites à l'avenir).
Support global (par exemple préalloc * .go)