Refactor libpf.Frame mappings

- use unique FrameMappingData to reduce the Frame size
- construct FrameMappingData directly from the cached ELF info
- remove the FileID LRU cache as unneeded
- replace processmnanager.processInfo.mappings map with a sorted
  slice of the []Mappings
- atomically do batch updates of the []Mappings
- remove processmanager.processInfo.mappingsByFileID as redudant

TODO:
- eim should probably get libpf.FrameMappingFile instead of host.FileID
- eventually move processmanager.Mapping to interpreters and pass it
  as the mapping type

Author: fabled

interpreter/dotnet/instance.go

@@ -603,7 +603,7 @@ func (i *dotnetInstance) SynchronizeMappings(ebpf interpreter.EbpfHandler,
 		log.Debugf("%v -> %v guid %v", m.Path, info.simpleName, info.guid)
 
 		exeReporter.ReportExecutable(&reporter.ExecutableMetadata{
-			MappingFile: info.file,
+			MappingFile: info.mapping.Value().File,
 			Process:     pr,
 			Mapping:     m,
 		})
@@ -736,7 +736,7 @@ func (i *dotnetInstance) Symbolize(frame *host.Frame, frames *libpf.Frames) erro
 			AddressOrLineno: libpf.AddressOrLineno(pcOffset),
 			FunctionName:    module.resolveR2RMethodName(pcOffset),
 			SourceFile:      module.simpleName,
-			MappingFile:     module.file,
+			Mapping:         module.mapping,
 		})
 	case codeJIT:
 		// JITted frame in anonymous mapping
@@ -765,7 +765,7 @@ func (i *dotnetInstance) Symbolize(frame *host.Frame, frames *libpf.Frames) erro
 			SourceFile:      method.module.simpleName,
 			FunctionName:    methodName,
 			FunctionOffset:  ilOffset,
-			MappingFile:     method.module.file,
+			Mapping:         method.module.mapping,
 		})
 	default:
 		// Stub code

interpreter/dotnet/pe.go

@@ -258,7 +258,7 @@ const (
 type peInfo struct {
 	err          error
 	lastModified int64
-	file         libpf.FrameMappingFile
+	mapping      libpf.FrameMapping
 	simpleName   libpf.String
 	guid         string
 	typeSpecs    []peTypeSpec
@@ -1251,11 +1251,14 @@ func (pc *peCache) Get(pr process.Process, mapping *process.Mapping) *peInfo {
 	}
 	info.err = info.parse(file)
 	if info.err == nil {
-		info.file = libpf.NewFrameMappingFile(libpf.FrameMappingFileData{
+		mf := libpf.NewFrameMappingFile(libpf.FrameMappingFileData{
 			FileID:     fileID,
 			FileName:   libpf.Intern(path.Base(mapping.Path.String())),
 			GnuBuildID: info.guid,
 		})
+		info.mapping = libpf.NewFrameMapping(libpf.FrameMappingData{
+			File: mf,
+		})
 	}
 	pc.peInfoCache.Add(key, info)
 	return info

kallsyms/kallsyms.go

@@ -65,7 +65,7 @@ type Module struct {
 	mtime int64
 	stub  bool
 
-	mappingFile libpf.FrameMappingFile
+	mapping libpf.FrameMapping
 
 	names   []byte
 	symbols []symbol
@@ -181,10 +181,12 @@ var loadModuleMetadata = func(m *Module, name string, oldMtime int64) bool {
 	if err == nil && len(buildID) >= 16 {
 		fileID = libpf.FileIDFromKernelBuildID(buildID)
 	}
-	m.mappingFile = libpf.NewFrameMappingFile(libpf.FrameMappingFileData{
-		FileID:     fileID,
-		FileName:   libpf.Intern(name),
-		GnuBuildID: buildID,
+	m.mapping = libpf.NewFrameMapping(libpf.FrameMappingData{
+		File: libpf.NewFrameMappingFile(libpf.FrameMappingFileData{
+			FileID:     fileID,
+			FileName:   libpf.Intern(name),
+			GnuBuildID: buildID,
+		}),
 	})
 	return true
 }
@@ -216,8 +218,8 @@ func (m *Module) End() libpf.Address {
 	return m.end
 }
 
-func (m *Module) MappingFile() libpf.FrameMappingFile {
-	return m.mappingFile
+func (m *Module) Mapping() libpf.FrameMapping {
+	return m.mapping
 }
 
 // LookupSymbolByAddress resolves the `pc` address to the function and offset from it.

libpf/trace.go

@@ -29,17 +29,44 @@ func NewFrameMappingFile(data FrameMappingFileData) FrameMappingFile {
 	return FrameMappingFile{value: unique.Make(data)}
 }
 
-// Valid determines if the FrameMappingFile is valid.
-func (fmf FrameMappingFile) Valid() bool {
-	return fmf != FrameMappingFile{}
-}
-
 // Value returns the dereferences FrameMappingFileData.
-// This can be done only if it the FrameMappingFile is Valid.
 func (fmf FrameMappingFile) Value() FrameMappingFileData {
 	return fmf.value.Value()
 }
 
+// FrameMappingData contains data regarding file backed mapping.
+type FrameMappingData struct {
+	// File is a reference to data about the backing file.
+	File FrameMappingFile
+	// Start contains the mapping start address (file virtual address).
+	Start      Address
+	// End contains the mapping end address (file virtual address).
+	End        Address
+	// FileOffset is the offset within the file for this mapping.
+	FileOffset uint64
+}
+
+// FrameMapping is an interned FrameMappingData reference.
+type FrameMapping struct {
+	value unique.Handle[FrameMappingData]
+}
+
+// NewFrameMapping interns given FrameMappingData.
+func NewFrameMapping(data FrameMappingData) FrameMapping {
+	return FrameMapping{value: unique.Make(data)}
+}
+
+// Valid determines if the FrameMapping is valid.
+func (fmf FrameMapping) Valid() bool {
+	return fmf != FrameMapping{}
+}
+
+// Value returns the dereferences FrameMappingData.
+// This can be done only if it the FrameMapping is Valid.
+func (fmf FrameMapping) Value() FrameMappingData {
+	return fmf.value.Value()
+}
+
 // Frame represents one frame in a stack trace.
 type Frame struct {
 	// Type is the frame type.
@@ -52,16 +79,11 @@ type Frame struct {
 	SourceFile String
 	// SourceLine is the source code level line number of this frame.
 	SourceLine SourceLineno
-
 	// An address in ELF VA space (native frame) or line number (interpreted frame).
 	AddressOrLineno AddressOrLineno
-
-	// File metadata for the backing file of the mapping.
-	MappingFile FrameMappingFile
-
-	MappingStart      Address
-	MappingEnd        Address
-	MappingFileOffset uint64
+	// Mapping is a reference to the mapping data to which this Frame coresspends to.
+	// Available only for frames executing on a file backed memory mapping.
+	Mapping FrameMapping
 }
 
 // Frames is a list of interned frames.

processmanager/helpers.go

@@ -4,80 +4,9 @@
 package processmanager // import "go.opentelemetry.io/ebpf-profiler/processmanager"
 
 import (
-	lru "github.com/elastic/go-freelru"
-	log "github.com/sirupsen/logrus"
-
-	"go.opentelemetry.io/ebpf-profiler/host"
-	"go.opentelemetry.io/ebpf-profiler/libpf"
 	"go.opentelemetry.io/ebpf-profiler/reporter"
 )
 
-type lruFileIDMapper struct {
-	cache *lru.SyncedLRU[host.FileID, libpf.FrameMappingFile]
-}
-
-// identityHash maps the host.FileID to a 32bit value.
-// No need to explicitly hash the FileID, since it's already a hash value.
-func identityHash(key host.FileID) uint32 {
-	return uint32(key)
-}
-
-func newFileIDMapper(size int) (*lruFileIDMapper, error) {
-	cache, err := lru.NewSynced[host.FileID, libpf.FrameMappingFile](uint32(size), identityHash)
-	if err != nil {
-		return nil, err
-	}
-	return &lruFileIDMapper{cache}, nil
-}
-
-func (fm *lruFileIDMapper) Get(key host.FileID) (libpf.FrameMappingFile, bool) {
-	if mappingFile, ok := fm.cache.Get(key); ok {
-		return mappingFile, true
-	}
-
-	log.Warnf("Failed to lookup file ID %#x", key)
-	return libpf.FrameMappingFile{}, false
-}
-
-func (fm *lruFileIDMapper) Set(key host.FileID, val libpf.FrameMappingFile) {
-	fm.cache.Add(key, val)
-	log.Debugf("Stored file ID mapping %#x -> %#x", key, val.Value())
-}
-
-var _ FileIDMapper = (*lruFileIDMapper)(nil)
-
-// MapFileIDMapper implements the FileIDMApper using a map (for testing)
-type MapFileIDMapper struct {
-	fileMap map[host.FileID]libpf.FrameMappingFile
-}
-
-func NewMapFileIDMapper() *MapFileIDMapper {
-	return &MapFileIDMapper{
-		fileMap: make(map[host.FileID]libpf.FrameMappingFile),
-	}
-}
-
-func (fm *MapFileIDMapper) Get(key host.FileID) (libpf.FrameMappingFile, bool) {
-	if value, ok := fm.fileMap[key]; ok {
-		return value, true
-	}
-	return libpf.FrameMappingFile{}, true
-}
-
-func (fm *MapFileIDMapper) Set(key host.FileID, value libpf.FrameMappingFile) {
-	fm.fileMap[key] = value
-}
-
-var _ FileIDMapper = (*MapFileIDMapper)(nil)
-
-// FileIDMapper is responsible for mapping between 64-bit file IDs to the frame mapping metadata.
-type FileIDMapper interface {
-	// Retrieve the metadata for given 64-bit file ID.
-	Get(fileID host.FileID) (libpf.FrameMappingFile, bool)
-	// Associate the metadata for given 64-bit file ID.
-	Set(fileID host.FileID, metadata libpf.FrameMappingFile)
-}
-
 // executableReporterStub is a stub to implement reporter.ExecutableReporter which is used
 // as the reporter by default. This can be overridden on at processmanager creation time.
 type executableReporterStub struct {

processmanager/manager.go

@@ -73,16 +73,9 @@ var (
 // fileIDMapper and symbolReporter. Specify nil for fileIDMapper to use the default
 // implementation.
 func New(ctx context.Context, includeTracers types.IncludedTracers, monitorInterval time.Duration,
-	ebpf pmebpf.EbpfHandler, fileIDMapper FileIDMapper, traceReporter reporter.TraceReporter,
+	ebpf pmebpf.EbpfHandler, traceReporter reporter.TraceReporter,
 	exeReporter reporter.ExecutableReporter, sdp nativeunwind.StackDeltaProvider,
 	filterErrorFrames bool, includeEnvVars libpf.Set[string]) (*ProcessManager, error) {
-	if fileIDMapper == nil {
-		var err error
-		fileIDMapper, err = newFileIDMapper(lruFileIDCacheSize)
-		if err != nil {
-			return nil, fmt.Errorf("failed to initialize file ID mapping: %v", err)
-		}
-	}
 	if exeReporter == nil {
 		exeReporter = executableReporterStub{}
 	}
@@ -114,7 +107,6 @@ func New(ctx context.Context, includeTracers types.IncludedTracers, monitorInter
 		exitEvents:               make(map[libpf.PID]times.KTime),
 		pidToProcessInfo:         make(map[libpf.PID]*processInfo),
 		ebpf:                     ebpf,
-		FileIDMapper:             fileIDMapper,
 		elfInfoCache:             elfInfoCache,
 		frameCache:               frameCache,
 		traceReporter:            traceReporter,
@@ -240,10 +232,16 @@ func (pm *ProcessManager) symbolizeFrame(pid libpf.PID, bpfFrame *host.Frame, fr
 // if non-trivial cacheable conversion was done.
 func (pm *ProcessManager) convertFrame(pid libpf.PID, frame *host.Frame, dst *libpf.Frames) bool {
 	switch frame.Type.Interpreter() {
-	case libpf.UnknownInterp:
-		log.Errorf("Unexpected frame type 0x%02X (neither error nor interpreter frame)",
+	case libpf.UnknownInterp, libpf.Kernel:
+		log.Errorf("Unexpected frame type 0x%02X (neither error nor usermode frame)",
 			uint8(frame.Type))
-	case libpf.Native, libpf.Kernel:
+	case libpf.Native:
+		// Attempt symbolization of native frames. It is best effort and
+		// provides non-symbolized frames if no native symbolizer is active.
+		if err := pm.symbolizeFrame(pid, frame, dst); err == nil {
+			return true
+		}
+
 		// The BPF code classifies whether an address is a return address or not.
 		// Return addresses are where execution resumes when returning to the stack
 		// frame and point to the **next instruction** after the call instruction
@@ -264,43 +262,13 @@ func (pm *ProcessManager) convertFrame(pid libpf.PID, frame *host.Frame, dst *li
 		}
 
 		// Locate mapping info for the frame.
-		var mappingStart, mappingEnd libpf.Address
-		var fileOffset uint64
-		if frame.Type.Interpreter() == libpf.Native {
-			if mapping, ok := pm.findMappingForTrace(pid, frame.File, frame.Lineno); ok {
-				mappingStart = mapping.Vaddr - libpf.Address(mapping.Bias)
-				mappingEnd = mappingStart + libpf.Address(mapping.Length)
-				fileOffset = mapping.FileOffset
-			}
-		}
-
-		// Attempt symbolization of native frames. It is best effort and
-		// provides non-symbolized frames if no native symbolizer is active.
-		if err := pm.symbolizeFrame(pid, frame, dst); err == nil {
-			return true
-		}
-
-		if mappingFile, ok := pm.FileIDMapper.Get(frame.File); ok {
-			dst.Append(&libpf.Frame{
-				Type:              frame.Type,
-				AddressOrLineno:   relativeRIP,
-				MappingStart:      mappingStart,
-				MappingEnd:        mappingEnd,
-				MappingFileOffset: fileOffset,
-				MappingFile:       mappingFile,
+		mapping := pm.findMappingForTrace(pid, frame.File,
+			libpf.Address(frame.Lineno))
+		dst.Append(&libpf.Frame{
+			Type:            frame.Type,
+			AddressOrLineno: relativeRIP,
+			Mapping:         mapping,
 			})
-		} else {
-			log.Debugf(
-				"file ID lookup failed for PID %d, frame type %d",
-				pid, frame.Type)
-
-			dst.Append(&libpf.Frame{
-				Type:              frame.Type,
-				MappingStart:      mappingStart,
-				MappingEnd:        mappingEnd,
-				MappingFileOffset: fileOffset,
-			})
-		}
 	default:
 		err := pm.symbolizeFrame(pid, frame, dst)
 		if err == nil {