Guía de Optimización - Find Missing Number

Optimización del Binario Go - Find Missing Number

Análisis del Tamaño Actual

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}}' ./...

Técnicas de Optimización de Tamaño

1. Compilación con Flags de Optimización

# 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

2. Compilación Ultra-Optimizada

# 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_number

3. Build Tags para Diferentes Versiones

Crear 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" .

Técnicas de Optimización de Velocidad

1. Optimizaciones del Compilador

# 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)

2. Profile-Guided Optimization (PGO)

# 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 .

3. Optimización del Algoritmo

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
}

Estrategias Avanzadas de Optimización

1. Eliminación de Dependencias Innecesarias

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

2. Pool de Objetos para Benchmarks

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

3. Compilación Condicional para Diferentes Targets

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

Comparación de Tamaños

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%

Script de Automatización

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=. -benchmem

Recomendaciones Específicas

Para Producción

go build -ldflags="-s -w -X main.version=$(git describe --tags)" .

Para Distribución

# 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 .

Para Desarrollo

# Con información de debug para profiling
go build -gcflags="-N -l" .

Medición de Impacto

# Medir tamaño
ls -lah find_number*

# Medir velocidad
time ./find_number > /dev/null

# Benchmark detallado
go test -bench=BenchmarkFindMissingNumber -benchtime=10s -count=5

Herramientas Adicionales

  1. Análisis de dependencias: go mod graph
  2. Análisis de símbolos: go tool nm find_number
  3. Profiling: go tool pprof
  4. Análisis de escape: go build -gcflags="-m"

🔙 ← Volver atrás