Structs — Optimization Exercises¶

import "unsafe"

// Original (with padding analysis):
type UserProfileBad struct {
    Active    bool       // 1 + 7 padding
    UserID    int64      // 8 (offset 8)
    IsAdmin   bool       // 1 + 7 padding
    Score     float64    // 8 (offset 24)
    Verified  bool       // 1 + 7 padding
    CreatedAt time.Time  // 24 (offset 40)
    Name      string     // 16 (offset 64)
    Age       int32      // 4 (offset 80)
    Premium   bool       // 1 + 3 padding
}
// unsafe.Sizeof = 88 bytes

// Optimized: largest types first, then smaller, bools last together
type UserProfileGood struct {
    CreatedAt time.Time  // 24 (offset 0)  — largest first
    Name      string     // 16 (offset 24)
    UserID    int64      // 8  (offset 40)
    Score     float64    // 8  (offset 48)
    Age       int32      // 4  (offset 56)
    Active    bool       // 1  (offset 60) — group bools
    IsAdmin   bool       // 1  (offset 61)
    Verified  bool       // 1  (offset 62)
    Premium   bool       // 1  (offset 63)
}
// unsafe.Sizeof = 64 bytes  — saves 24 bytes (27%)!

// Verification:
var _ = [1]struct{}{}[unsafe.Sizeof(UserProfileGood{}) - 64] // compile-time size assert

// Change to value slice — GC doesn't scan float64 fields
type Point struct{ X, Y float64 }

func (p Point) Magnitude() float64 { // value receiver for small struct
    return math.Sqrt(p.X*p.X + p.Y*p.Y)
}

func processPoints(points []Point) []float64 { // slice of values, not pointers
    results := make([]float64, len(points))
    for i := range points {
        results[i] = points[i].Magnitude() // index access avoids copy overhead
    }
    return results
}

points := make([]Point, 1000000) // contiguous memory — cache friendly!
for i := range points {
    points[i] = Point{X: float64(i), Y: float64(i)}
}
processPoints(points)

type LargeConfig struct {
    Settings  [100]string
    Weights   [100]float64
    Labels    [50]string
    Metadata  map[string]string
}

// Pointer receivers — pass 8 bytes instead of 3200+
func (c *LargeConfig) IsValid() bool {
    return len(c.Settings) > 0 && c.Weights[0] >= 0
}

func (c *LargeConfig) GetSetting(i int) string {
    if i >= 0 && i < len(c.Settings) {
        return c.Settings[i]
    }
    return ""
}

var requestPool = sync.Pool{
    New: func() interface{} {
        return &ParsedRequest{
            Headers: make(map[string]string, 20),
            Params:  make(map[string]string, 10),
            Body:    make([]byte, 0, 4096),
        }
    },
}

func parseHTTPRequest(raw []byte) *ParsedRequest {
    req := requestPool.Get().(*ParsedRequest)
    req.reset() // clear all fields, keep allocated memory

    // ... parse raw bytes into req ...
    return req
}

func releaseRequest(req *ParsedRequest) {
    requestPool.Put(req)
}

func (r *ParsedRequest) reset() {
    r.Method = ""
    r.Path = ""
    for k := range r.Headers { delete(r.Headers, k) }
    for k := range r.Params  { delete(r.Params, k) }
    r.Body = r.Body[:0]
}

// Option 1: Type-specific processor (Go generics, 1.18+)
type EventProcessor[T any] struct {
    handler func(T) error
}

func (ep *EventProcessor[T]) Handle(event T) error {
    return ep.handler(event)
}

// No boxing, no type assertions, full type safety
orderProcessor := &EventProcessor[OrderEvent]{
    handler: func(e OrderEvent) error {
        fmt.Printf("Order #%d: $%.2f\n", e.OrderID, e.Amount)
        return nil
    },
}
orderProcessor.Handle(OrderEvent{OrderID: 42, Amount: 99.99})

// Option 2: Typed event interface (pre-generics style)
type Event interface {
    eventMarker()
}

type OrderEvent struct {
    OrderID int64
    Amount  float64
}
func (OrderEvent) eventMarker() {}

type TypedProcessor struct {
    orderHandler func(OrderEvent) error
    // ... other typed handlers
}

func (p *TypedProcessor) Handle(e Event) error {
    switch evt := e.(type) {
    case OrderEvent:
        if p.orderHandler != nil {
            return p.orderHandler(evt)
        }
    }
    return nil
}

// Option 1: Sort indices, not structs
func sortByPrice(products []Product) []int {
    indices := make([]int, len(products))
    for i := range indices {
        indices[i] = i
    }
    sort.Slice(indices, func(i, j int) bool {
        return products[indices[i]].Price < products[indices[j]].Price
    })
    return indices // caller uses products[idx] for sorted access
}

// Option 2: Sort slice of lightweight keys
type productKey struct {
    price float64
    index int
}

func sortedByPrice(products []Product) []Product {
    keys := make([]productKey, len(products))
    for i, p := range products {
        keys[i] = productKey{price: p.Price, index: i}
    }
    sort.Slice(keys, func(i, j int) bool {
        return keys[i].price < keys[j].price
    })
    result := make([]Product, len(products))
    for i, k := range keys {
        result[i] = products[k.index]
    }
    return result
}

// Option 3: Use pointer slice (swaps pointers, not structs)
func sortByPricePtr(products []*Product) {
    sort.Slice(products, func(i, j int) bool {
        return products[i].Price < products[j].Price
    })
}

// GC-friendly event for append-heavy logs
// Use string interning + fixed-size fields where possible

type EventKind uint8
const (
    ActionLogin  EventKind = iota
    ActionLogout
    ActionPurchase
    ActionView
)

// Compact event — NO pointer fields!
type CompactEvent struct {
    TimestampNano int64     // 8 bytes — no pointer
    UserID        int64     // 8 bytes — no pointer (use int ID, not string)
    Kind          EventKind // 1 byte  — enum, no pointer
    Amount        int32     // 4 bytes — cents, no float
    _             [3]byte   // padding to align
}
// Total: 24 bytes, ZERO pointer fields → GC never scans this!

type EventLog struct {
    events []CompactEvent // GC ignores all elements!
}

// For string metadata: use a separate interned string table
type StringTable struct {
    mu      sync.RWMutex
    forward map[string]uint32
    reverse []string
}

func (st *StringTable) Intern(s string) uint32 {
    st.mu.RLock()
    if id, ok := st.forward[s]; ok {
        st.mu.RUnlock()
        return id
    }
    st.mu.RUnlock()
    st.mu.Lock()
    defer st.mu.Unlock()
    if id, ok := st.forward[s]; ok { return id }
    id := uint32(len(st.reverse))
    st.reverse = append(st.reverse, s)
    st.forward[s] = id
    return id
}

const numShards = 256

type shardedScoreboard struct {
    shards [numShards]struct {
        sync.RWMutex
        scores map[string]int64
        _      [40]byte // cache line padding (Mutex=8, map=8, padding=40 → 56 bytes close to 64)
    }
}

func NewShardedScoreboard() *shardedScoreboard {
    sb := &shardedScoreboard{}
    for i := range sb.shards {
        sb.shards[i].scores = make(map[string]int64)
    }
    return sb
}

func (sb *shardedScoreboard) shard(player string) int {
    h := fnv.New32a()
    h.Write([]byte(player))
    return int(h.Sum32()) % numShards
}

func (sb *shardedScoreboard) AddScore(player string, points int64) {
    s := &sb.shards[sb.shard(player)]
    s.Lock()
    s.scores[player] += points
    s.Unlock()
}

func (sb *shardedScoreboard) GetScore(player string) int64 {
    s := &sb.shards[sb.shard(player)]
    s.RLock()
    score := s.scores[player]
    s.RUnlock()
    return score
}

// For TopPlayers: collect all, sort externally
func (sb *shardedScoreboard) Snapshot() map[string]int64 {
    result := make(map[string]int64)
    for i := range sb.shards {
        sb.shards[i].RLock()
        for k, v := range sb.shards[i].scores {
            result[k] = v
        }
        sb.shards[i].RUnlock()
    }
    return result
}

// Option 1: Custom binary serialization — zero allocation for fixed fields
import "encoding/binary"

type MetricFixed struct {
    Value     float64
    Timestamp int64
    NameLen   uint8
    Name      [64]byte // fixed-size name buffer — no allocation!
}

func (m *MetricFixed) SetName(name string) {
    n := copy(m.Name[:], name)
    m.NameLen = uint8(n)
}

func (m *MetricFixed) SerializeTo(buf []byte) int {
    binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(m.Value))
    binary.LittleEndian.PutUint64(buf[8:16], uint64(m.Timestamp))
    buf[16] = m.NameLen
    copy(buf[17:], m.Name[:m.NameLen])
    return 17 + int(m.NameLen)
}

// Option 2: Reusable buffer with append
var serBufPool = sync.Pool{New: func() interface{} {
    b := make([]byte, 0, 256)
    return &b
}}

func (m Metric) AppendTo(dst []byte) []byte {
    dst = append(dst, m.Name...)
    dst = append(dst, ':')
    dst = strconv.AppendFloat(dst, m.Value, 'f', 4, 64)
    dst = append(dst, ' ')
    dst = strconv.AppendInt(dst, m.Timestamp, 10)
    return dst
}

// Option 3: Use a streaming encoder (e.g., easyjson, ffjson)
// go generate calls easyjson which generates custom marshal code:
//go:generate easyjson metric.go

// Option 1: Slice of values (Structure of Pointers → Structure of Values)
type Simulation struct {
    particles []Particle // direct storage — contiguous memory
}

func (s *Simulation) Step(dt float64) {
    for i := range s.particles { // index access — avoids range copy
        p := &s.particles[i]     // pointer to slice element — still safe
        if !p.Alive { continue }
        p.X += p.VX * dt
        p.Y += p.VY * dt
        p.Z += p.VZ * dt
    }
}

// Option 2: Structure of Arrays (SoA) — best for SIMD/vectorization
type SimulationSoA struct {
    X, Y, Z   []float64
    VX, VY, VZ []float64
    Mass       []float64
    Alive      []bool
    n          int
}

func (s *SimulationSoA) Step(dt float64) {
    for i := 0; i < s.n; i++ {
        if !s.Alive[i] { continue }
        s.X[i] += s.VX[i] * dt
        s.Y[i] += s.VY[i] * dt
        s.Z[i] += s.VZ[i] * dt
    }
}
// SoA layout: all X values contiguous — CPU prefetcher and SIMD can vectorize!

type OrderStatus uint8

const (
    StatusDraft     OrderStatus = iota
    StatusConfirmed
    StatusShipped
    StatusDelivered
    StatusCancelled
    statusCount
)

// Static transition table — created once, zero-allocation lookup
var validTransitions = [statusCount][]OrderStatus{
    StatusDraft:     {StatusConfirmed, StatusCancelled},
    StatusConfirmed: {StatusShipped, StatusCancelled},
    StatusShipped:   {StatusDelivered},
    StatusDelivered: {},
    StatusCancelled: {},
}

// Pre-computed transition bitmask for O(1) check
var transitionMask [statusCount]uint32

func init() {
    for from, tos := range validTransitions {
        for _, to := range tos {
            transitionMask[from] |= 1 << uint(to)
        }
    }
}

type HistoryEntry struct {
    From, To  OrderStatus
    At        int64 // unix timestamp — no allocation
}

type Order struct {
    Status  OrderStatus
    History []HistoryEntry // fixed-size, no strings
    Items   []Item
    Total   int64 // cents
}

func (o *Order) Transition(newStatus OrderStatus) error {
    if int(o.Status) >= int(statusCount) {
        return fmt.Errorf("invalid status: %d", o.Status)
    }
    if transitionMask[o.Status]&(1<<uint(newStatus)) == 0 {
        return fmt.Errorf("invalid transition: %d → %d", o.Status, newStatus)
    }
    o.History = append(o.History, HistoryEntry{
        From: o.Status,
        To:   newStatus,
        At:   time.Now().UnixNano(),
    })
    o.Status = newStatus
    return nil
}