Para analizar el tamaño del binario, primero necesitamos compilarlo y ver su tamaño:
# Compilar binario normal
go build .
ls -lah find_number
# Analizar dependencias que contribuyen al tamaño
go list -f '{{.ImportPath}} {{.Target}}' ./...# Compilación optimizada básica
go build -ldflags="-s -w" .
# Explicación:
# -s: Omite tabla de símbolos y información de debug
# -w: Omite información de debug DWARF# Máxima optimización de tamaño
go build -ldflags="-s -w -extldflags=-static" -a -installsuffix cgo .
# Con compresión UPX (si está instalado)
go build -ldflags="-s -w" .
upx --best --lzma find_numberCrear versiones minimalistas del programa:
//go:build minimal
// +build minimal
package main
// Versión minimalista solo con el algoritmo core
func main() {
numbers := []int{1, 2, 3, 5, 6, 7, 8, 9, 10}
result := FindMissingNumber(numbers)
if result != nil {
fmt.Printf("Missing: %d\n", *result)
} else {
fmt.Println("No missing number found")
}
}# Compilar versión minimalista
go build -tags minimal -ldflags="-s -w" .# Compilación con optimizaciones de velocidad
go build -gcflags="-B -C" .
# Explicación:
# -B: Deshabilita bounds checking (usar con cuidado)
# -C: Deshabilita nilcheck (usar con cuidado)# Paso 1: Compilar con profiling habilitado
go build -o find_number_profile .
# Paso 2: Ejecutar y generar perfil
./find_number_profile > /dev/null
go tool pprof -text find_number_profile cpu.prof
# Paso 3: Compilar con PGO
go build -pgo=auto .Versión optimizada del algoritmo principal:
// Versión optimizada con menos asignaciones de memoria
func FindMissingNumberOptimized(numbers []int) *int {
if len(numbers) <= 1 {
return nil
}
// Usar variables locales para evitar recálculos
length := len(numbers)
sum := 0
min := numbers[0]
max := numbers[0]
// Una sola pasada optimizada
for _, num := range numbers {
sum += num
if num < min {
min = num
}
if num > max {
max = num
}
}
// Cálculo directo sin variables intermedias
missing := ((max-min+1)*(min+max))>>1 - sum
// Validación del rango
if missing < min || missing > max {
return nil
}
return &missing
}// Reemplazar fmt.Printf por escritura directa
import (
"os"
"strconv"
)
func printResult(result int) {
os.Stdout.WriteString("Missing: ")
os.Stdout.WriteString(strconv.Itoa(result))
os.Stdout.WriteString("\n")
}import "sync"
var slicePool = sync.Pool{
New: func() interface{} {
return make([]int, 0, 1000)
},
}
func BenchmarkFindMissingNumberPooled(b *testing.B) {
for i := 0; i < b.N; i++ {
numbers := slicePool.Get().([]int)
numbers = numbers[:0] // Reset length
// ... usar el slice ...
slicePool.Put(numbers)
}
}//go:build !minimal
// +build !minimal
package main
// Versión completa con todos los tests
func main() {
RunAllTests()
}//go:build minimal
// +build minimal
package main
// Versión minimalista
func main() {
numbers := []int{1, 2, 3, 5, 6}
result := FindMissingNumber(numbers)
if result != nil {
fmt.Printf("Missing: %d\n", *result)
} else {
fmt.Println("No missing number found")
}
}| Método de Compilación | Tamaño Estimado | Velocidad |
|---|---|---|
go build (normal) |
~2-3 MB | Baseline |
go build -ldflags="-s -w" |
~1-2 MB | Baseline |
| Con build tags minimal | ~800KB-1MB | +5-10% |
| Con UPX compression | ~400-600KB | -2-5% |
| Optimizado + minimal | ~300-500KB | +10-15% |
Crear un script para probar diferentes optimizaciones:
#!/bin/bash
# optimize.sh
echo "=== Optimización de Binario Go ==="
# Compilación normal
echo "1. Compilación normal:"
go build -o find_number_normal .
ls -lah find_number_normal
# Compilación optimizada
echo "2. Compilación optimizada (-s -w):"
go build -ldflags="-s -w" -o find_number_optimized .
ls -lah find_number_optimized
# Compilación minimalista
echo "3. Compilación minimalista:"
go build -tags minimal -ldflags="-s -w" -o find_number_minimal .
ls -lah find_number_minimal
# Benchmarks de velocidad
echo "4. Benchmarks de velocidad:"
go test -bench=. -benchmemgo build -ldflags="-s -w -X main.version=$(git describe --tags)" .# Multi-arquitectura optimizada
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o find_number_linux_amd64 .
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o find_number_windows_amd64.exe .
GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o find_number_darwin_amd64 .# Con información de debug para profiling
go build -gcflags="-N -l" .# Medir tamaño
ls -lah find_number*
# Medir velocidad
time ./find_number > /dev/null
# Benchmark detallado
go test -bench=BenchmarkFindMissingNumber -benchtime=10s -count=5go mod graphgo tool nm find_numbergo tool pprofgo build -gcflags="-m"