btf: introduce caching to the string table to speed up ext info loading

when parsing line infos, we end up querying multiple times the same
offest (especially the file name), and we currently create a new string
each time. This commit deduplicates this allocation by caching the
string.

Signed-off-by: Paul Cacheux <[email protected]>

Author: paulcacheux

btf/ext_info.go

@@ -559,12 +559,12 @@ func LoadLineInfos(reader io.Reader, bo binary.ByteOrder, recordNum uint32, spec
 }
 
 func newLineInfo(li bpfLineInfo, strings *stringTable) (LineOffset, error) {
-	line, err := strings.Lookup(li.LineOff)
+	line, err := strings.LookupCached(li.LineOff)
 	if err != nil {
 		return LineOffset{}, fmt.Errorf("lookup of line: %w", err)
 	}
 
-	fileName, err := strings.Lookup(li.FileNameOff)
+	fileName, err := strings.LookupCached(li.FileNameOff)
 	if err != nil {
 		return LineOffset{}, fmt.Errorf("lookup of filename: %w", err)
 	}

btf/strings.go

@@ -12,6 +12,8 @@ import (
 type stringTable struct {
 	base  *stringTable
 	bytes []byte
+
+	cache map[uint32]string
 }
 
 // sizedReader is implemented by bytes.Reader, io.SectionReader, strings.Reader, etc.
@@ -88,6 +90,30 @@ func (st *stringTable) lookupSlow(offset uint32) ([]byte, error) {
 	return st.bytes[offset : offset+uint32(i)], nil
 }
 
+// LookupCache returns the string at the given offset, caching the result
+// for future lookups.
+func (cst *stringTable) LookupCached(offset uint32) (string, error) {
+	// Fast path: zero offset is the empty string, looked up frequently.
+	if offset == 0 {
+		return "", nil
+	}
+
+	if str, ok := cst.cache[offset]; ok {
+		return str, nil
+	}
+
+	str, err := cst.Lookup(offset)
+	if err != nil {
+		return "", err
+	}
+
+	if cst.cache == nil {
+		cst.cache = make(map[uint32]string)
+	}
+	cst.cache[offset] = str
+	return str, nil
+}
+
 // stringTableBuilder builds BTF string tables.
 type stringTableBuilder struct {
 	length  uint32