interpreter/go - Benchmark

gistfile1.txt

$ benchstat old.txt new.txt
goos: linux
goarch: amd64
pkg: go.opentelemetry.io/ebpf-profiler/interpreter/go
cpu: 12th Gen Intel(R) Core(TM) i7-12700H
          │   old.txt   │               new.txt               │
          │   sec/op    │   sec/op     vs base                │
Golang-20   6.352m ± 1%   4.877m ± 7%  -23.23% (p=0.000 n=10)

          │  old.txt   │                   new.txt                    │
          │    B/op    │      B/op        vs base                     │
Golang-20   862.0 ± 1%   12059763.5 ± 0%  +1398944.49% (p=0.000 n=10)

          │  old.txt   │                 new.txt                  │
          │ allocs/op  │   allocs/op    vs base                   │
Golang-20   24.00 ± 0%   23121.00 ± 0%  +96237.50% (p=0.000 n=10)

go_test.go

package golang

// Benchmark for https://github.com/open-telemetry/opentelemetry-ebpf-profiler/tree/main/interpreter/go

import (
	"os"
	"runtime"
	"strings"
	"testing"

	"go.opentelemetry.io/ebpf-profiler/host"
	"go.opentelemetry.io/ebpf-profiler/interpreter"
	"go.opentelemetry.io/ebpf-profiler/libpf"
	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
	"go.opentelemetry.io/ebpf-profiler/process"
	"go.opentelemetry.io/ebpf-profiler/remotememory"
	"go.opentelemetry.io/ebpf-profiler/reporter"
	"go.opentelemetry.io/ebpf-profiler/util"
)

// mockReporter implements reporter.SymbolReporter for testing
type mockReporter struct {
	b             *testing.B
	frameMetadata map[libpf.FrameID]*reporter.FrameMetadataArgs
}

func newMockReporter(b *testing.B) *mockReporter {
	return &mockReporter{
		b:             b,
		frameMetadata: make(map[libpf.FrameID]*reporter.FrameMetadataArgs),
	}
}

func (m *mockReporter) CompareFunctionName(fn string) {
	if len(m.frameMetadata) != 1 {
		m.b.Fatalf("Expected a single entry but got %d", len(m.frameMetadata))
	}
	for _, v := range m.frameMetadata {
		// The returned anonymous function has the suffic 'func1'.
		// Therefore check only for a matching prefix.
		if !strings.HasPrefix(v.FunctionName, fn) {
			m.b.Fatalf("Expected '%s()' but got '%s()'", fn, v.FunctionName)
		}
	}
}

func (m *mockReporter) FrameMetadata(args *reporter.FrameMetadataArgs) {
	m.frameMetadata[args.FrameID] = args
}

func (m *mockReporter) ExecutableMetadata(args *reporter.ExecutableMetadataArgs) {
	// Not used in this test
}

func (m *mockReporter) FrameKnown(frameID libpf.FrameID) bool {
	_, exists := m.frameMetadata[frameID]
	return exists
}

func (m *mockReporter) ExecutableKnown(fileID libpf.FileID) bool {
	return false
}

func BenchmarkGolang(b *testing.B) {
	pc, _, _, _ := runtime.Caller(1)
	fn := runtime.FuncForPC(pc)
	exec, err := os.Executable()
	if err != nil {
		b.Fatalf("Failed to get the executable: %v", err)
	}

	libpfPID := libpf.PID(os.Getpid())
	pid := process.New(libpfPID, libpfPID)

	elfRef := pfelf.NewReference(exec, pid)
	hostFileID, err := host.FileIDFromBytes([]byte{0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55})
	if err != nil {
		b.Fatalf("Failed to create hostID: %v", err)
	}
	loaderInfo := interpreter.NewLoaderInfo(hostFileID, elfRef, []util.Range{})
	rm := remotememory.NewProcessVirtualMemory(libpfPID)
	symReporter := newMockReporter(b)

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		gD, err := Loader(nil, loaderInfo)
		if err != nil {
			b.Fatalf("Failed to create loader: %v", err)
		}

		gI, err := gD.Attach(nil, libpfPID, 0x0, rm)
		if err != nil {
			b.Fatalf("Failed to create instance: %v", err)
		}

		trace := libpf.Trace{}

		if err := gI.Symbolize(symReporter, &host.Frame{
			File:   hostFileID,
			Lineno: libpf.AddressOrLineno(pc),
			Type:   libpf.FrameType(libpf.Native),
		}, &trace); err != nil {
			b.Fatalf("Failed to symbolize 0x%x: %v", pc, err)
		}

		symReporter.CompareFunctionName(fn.Name())
	}
}