2 B/op allocations, possible to make it zero alloc?

[ouvaa]

possible to make this zero alloc?

save this as main_test.go

go test -bench=. -benchmem

package main

import (
        //"math/rand"
        //"sync"
        "testing"
        //"time"

        "github.com/cilium/ebpf"
        "github.com/cilium/ebpf/rlimit"
)

// setupLRUMap creates an LRU map, handling any necessary setup for eBPF.
func setupLRUMap() (*ebpf.Map, error) {
        // Remove memory locking limits.
        if err := rlimit.RemoveMemlock(); err != nil {
                return nil, err
        }

        lruMapSpec := &ebpf.MapSpec{
                Name:       "lru_map",
                Type:       ebpf.LRUHash,
                KeySize:    4,
                ValueSize:  4,
                MaxEntries: 100,
        }

        return ebpf.NewMap(lruMapSpec)
}

// TestLRUMapAllocation ensures the LRU map can be allocated without error.
func TestLRUMapAllocation(t *testing.T) {
        _, err := setupLRUMap()
        if err != nil {
                t.Fatalf("Failed to create LRU map: %v", err)
        }
}

/*
// TestLRUMapConcurrentUpdates tests concurrent updates to the LRU map to ensure thread safety.
func TestLRUMapConcurrentUpdates(t *testing.T) {
        lruMap, err := setupLRUMap()
        if err != nil {
                t.Fatalf("Failed to create LRU map: %v", err)
        }
        defer lruMap.Close()

        const numGoroutines = 10
        const updatesPerGoroutine = 100000
        var wg sync.WaitGroup
        wg.Add(numGoroutines)
        for i := 0; i < numGoroutines; i++ {
                go func() {
                        defer wg.Done()
                        r := rand.New(rand.NewSource(time.Now().UnixNano()))
                        for j := 0; j < updatesPerGoroutine; j++ {
                                key := uint32(r.Intn(1000))
                                value := uint32(r.Intn(100))
                                if err := lruMap.Update(key, value, ebpf.UpdateAny); err != nil {
                                        t.Errorf("Failed to update LRU map: %v", err)
                                        return
                                }
                        }
                }()
        }
        wg.Wait()
}

// BenchmarkLRUMapUpdates performs single-threaded benchmarking of map updates.
func BenchmarkLRUMapUpdates(b *testing.B) {
        lruMap, err := setupLRUMap()
        if err != nil {
                b.Fatalf("Failed to create LRU map: %v", err)
        }
        defer lruMap.Close()

        r := rand.New(rand.NewSource(time.Now().UnixNano()))
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
                key := uint32(r.Intn(1000))
                value := uint32(r.Intn(100))
                if err := lruMap.Update(key, value, ebpf.UpdateAny); err != nil {
                        b.Errorf("Failed to update LRU map: %v", err)
                }
        }
}
*/

func BenchmarkLRUMapUpdatesParallel(b *testing.B) {
        lruMap, err := setupLRUMap()
        if err != nil {
                b.Fatalf("Failed to create LRU map: %v", err)
        }
        defer lruMap.Close()

        b.ResetTimer()  // Start the timer after setup is done.

        b.RunParallel(func(pb *testing.PB) {
                key := uint32(1)  // Static value for demonstration; adjust as needed.
                value := uint32(2)  // Static value for demonstration; adjust as needed.

                for pb.Next() {
                        if err := lruMap.Update(key, value, ebpf.UpdateAny); err != nil {
                                b.Errorf("Failed to update LRU map: %v", err)
                        }
                }
        })
}

/*
// BenchmarkLRUMapUpdatesParallel performs multi-threaded benchmarking of map updates using RunParallel.
func BenchmarkLRUMapUpdatesParallel(b *testing.B) {
        lruMap, err := setupLRUMap()
        if err != nil {
                b.Fatalf("Failed to create LRU map: %v", err)
        }
        defer lruMap.Close()

                r := rand.New(rand.NewSource(time.Now().UnixNano()))
        key := uint32(r.Intn(1000))
        value := uint32(r.Intn(100))
        b.RunParallel(func(pb *testing.PB) {
                for pb.Next() {
                        if err := lruMap.Update(key, value, ebpf.UpdateAny); err != nil {
                                b.Errorf("Failed to update LRU map: %v", err)
                        }
                }
        })
}

*/

[lmb]

This is a lot of code (some of it commented?) and not very much information to go on. Try getting a memory profile to figure out where the allocations are happening? If you can pinpoint where it happens I can probably tell you whether you can make them go away.

[ouvaa]

@lmb save the file as main_test.go and run as
go test -bench=. -benchmem

go test -bench=. -benchmem
goos: linux
goarch: amd64
pkg: ebpfgo/test
cpu: AMD Ryzen 5 7640HS w/ Radeon 760M Graphics     
BenchmarkLRUMapUpdatesParallel-12    	10278207	       118.3 ns/op	       8 B/op	       2 allocs/op
PASS
ok  	ebpfgo/test	1.338s

[ouvaa]

@lmb can u pls help answer this,
#1445

p.s. : sorry for the late reply. ebpf made me lose too much hair with chatgpt until i forgot about this question posted. i can live with 2 allocs / op.

pls help answer the question above. thx

[lmb]

Please try pinpointing the source code that allocates, you can use go tool pprof for that.