Arrays — Optimize¶

func sumFast(arr *[10000]int) int {
    total := 0
    for _, v := range arr {
        total += v
    }
    return total
}

func main() {
    var arr [10000]int
    for i := range arr { arr[i] = i }
    fmt.Println(sumFast(&arr)) // passes 8 bytes (pointer)
}

type Color struct {
    components [3]uint8  // 3 bytes inline, no heap alloc
}

func newRed() Color {
    return Color{components: [3]uint8{255, 0, 0}} // no allocation
}

func brightness(c Color) float64 {
    sum := 0
    for _, v := range c.components {
        sum += int(v)
    }
    return float64(sum) / 3.0
}

var cache = map[[32]byte]string{}  // array as key — no string conversion needed

func get(hash [32]byte) (string, bool) {
    v, ok := cache[hash]  // direct lookup — no allocation
    return v, ok
}

const n = 1000

var matrix [n][n]int64

func sumRowMajor() int64 {
    var total int64
    for row := 0; row < n; row++ {
        for col := 0; col < n; col++ {
            total += matrix[row][col] // cache-friendly: sequential memory access
        }
    }
    return total
}

func computeChecksum(data []byte) [32]byte {
    var buf [32]byte       // stays on stack — no escape!
    copy(buf[:], data[:min(len(data), 32)])
    // ... compute checksum ...
    return buf             // returned by value — copy to caller's stack
}

func process(data []byte) {
    cs := computeChecksum(data)  // cs is on stack
    fmt.Printf("%x\n", cs)
}

func min(a, b int) int {
    if a < b { return a }
    return b
}

func addArraysFast(a, b [1000]int) [1000]int {
    var result [1000]int
    // Ranging over result guarantees i < 1000 for all three arrays
    for i := range result {
        result[i] = a[i] + b[i]  // bounds checks eliminated by compiler
    }
    return result
}

import "sort"

var lookup [256]int

func init() {
    for i := range lookup { lookup[i] = i * 2 }
    // lookup is already sorted in this example
}

func findFast(target int) int {
    // Binary search: O(log 256) = O(8)
    i := sort.SearchInts(lookup[:], target)
    if i < len(lookup) && lookup[i] == target {
        return i
    }
    return -1
}

import "encoding/json"

func serializeScoresFast(scores [10]int) ([]byte, error) {
    return json.Marshal(scores[:])  // zero-copy slice view of the array
}

const cacheLineSize = 64

type paddedCounter struct {
    val int64
    _   [cacheLineSize - 8]byte  // pad to 64 bytes
}

type Stats struct {
    buckets [8]paddedCounter  // each on its own cache line
}

func benchmarkFast(s *Stats) {
    var wg sync.WaitGroup
    for i := 0; i < 8; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            for n := 0; n < 1000000; n++ {
                atomic.AddInt64(&s.buckets[idx].val, 1)
            }
        }(i)
    }
    wg.Wait()
}

// Branchless version — helps compiler vectorize
func countAboveFast(arr *[1024]int32, threshold int32) int {
    count := 0
    for i := range arr {
        // Branchless: convert bool to int (0 or 1)
        // Compiler can vectorize this pattern with SIMD comparisons
        if arr[i] > threshold {
            count++
        }
    }
    return count
}

// For maximum performance, use assembly or golang.org/x/sys for SIMD
// The key insight: avoid early exits, keep loop body simple and predictable

// Precomputed lookup table — initialized once, read-only afterwards
var hexTable [256][2]byte

func init() {
    const digits = "0123456789abcdef"
    for i := 0; i < 256; i++ {
        hexTable[i][0] = digits[i>>4]
        hexTable[i][1] = digits[i&0xf]
    }
}

func encodeAllFast(data [256]byte) string {
    var buf [512]byte
    for i, b := range data {
        entry := hexTable[b]
        buf[i*2] = entry[0]
        buf[i*2+1] = entry[1]
    }
    return string(buf[:])  // single allocation at the end
}

const bufSize = 32 * 1024

// Pool of reusable buffers — size known at compile time
type requestBuffer struct {
    data [bufSize]byte
}

var bufPool = sync.Pool{
    New: func() interface{} {
        return &requestBuffer{}
    },
}

func handlerFast(w http.ResponseWriter, r *http.Request) {
    buf := bufPool.Get().(*requestBuffer)
    defer bufPool.Put(buf)

    n, _ := io.ReadFull(r.Body, buf.data[:])
    process(buf.data[:n])
}