Descarga de prealloc - Descargar el código fuente prealloc

prealloc

Otras categorias

1.0.0

Descargar

prealloc

PreAlloc es una herramienta de análisis estático para encontrar declaraciones de corte que podrían ser preelocables.

Instalación

 go install github.com/alexkohler/prealloc@latest

Uso

Similar a otras herramientas de análisis estáticas GO (como Golint, GO VET), PreAlloc se puede invocar con uno o más nombres de archivo, directorios o paquetes nombrados por su ruta de importación. Prealloc también apoya el ... comodín.

 prealloc [flags] files/directories/packages

Banderas

-Simple (predeterminado verdadero) - Informe sugerencias de preaclocación solo en bucles simples que no tienen devoluciones/roturas/continuas/gotos en ellos. Establecer esto en falso puede aumentar los falsos positivos.
-rangeloops (predeterminado verdadero) - Informe sugerencias de preaclocación en bucles de rango.
-Forloops (falso predeterminado) - Informe sugerencias de preaclocación sobre bucles. Esto es falso de forma predeterminada debido a que generalmente hay cosas más extrañas que suceden dentro para bucles (al menos de lo que he observado en la biblioteca estándar).
-set_exit_status (predeterminado Falso) - Establezca el estado de salida en 1 si se encuentran problemas.

Objetivo

Si bien el GO intenta evitar la reasignación aumentando la capacidad de antemano, esto a veces no es suficiente para rebanadas más largas. Si el tamaño de una porción se conoce en el momento de su creación, debe especificarse.

Considere el siguiente punto de referencia: (esto se puede encontrar en PreAlloc_test.go en este repositorio)

 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 puede ver, no la preanlocación puede causar un éxito de rendimiento, principalmente debido a que tiene que reasignar la matriz subyacente. El patrón de referencia anterior es común en GO: declare una porción, luego escriba algún tipo de rango o para el bucle que se agrega o se indexa. El propósito de esta herramienta es marcar declaraciones de corte/bucle como la de BenchmarkNoPreallocate .

Ejemplo

Algunos ejemplos del GO 1.9.2 Fuente:

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

Incluso si el tamaño de la porción se está preellocando es pequeño, todavía hay una ganancia de rendimiento para especificar explícitamente la capacidad en lugar de dejar que append para descubrir que necesita preallocarse. Por supuesto, no es necesario que se realicen la preallocación en todas partes . El trabajo de esta herramienta es solo para ayudar a sugerir lugares donde uno debe considerar la pre -sellocación.

¿Cómo arreglo las sugerencias de Prealloc?

Durante la declaración de su corte, en lugar de usar el valor cero de la porción con var , inicialice con la función make incorporada de GO, pasando el tipo y la longitud apropiados. Esta longitud generalmente será lo que sea que esté variando. Arreglar los ejemplos de arriba se vería así:

 // 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: Si el rendimiento es absolutamente crítico, puede ser más eficiente usar copy en lugar de append por cortes más grandes. Para referencia, vea el siguiente punto de referencia:

 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

HACER

Configuración de si se ejecuta o no en archivos de prueba
Soporte para IFS incrustados (actualmente, PreAlloc solo encontrará descansos/devoluciones/continuas/gotos si están en un solo bloque if, me gustaría ampliar esto a compatibles con múltiples bloques en el futuro).
Globbbing Support (por ejemplo, PreAlloc *.go)