Refactor symbol_key. Everything is packed into u64 + i32. Refactor code for these changes.

Author: GitSparTV

perforator/agent/collector/pkg/config/config.go

@@ -98,6 +98,7 @@ type PodsDeploySystemConfig struct {
 type SymbolizerConfig struct {
 	Python symbolizer.SymbolizerConfig `yaml:"python"`
 	Php    symbolizer.SymbolizerConfig `yaml:"php"`
+	Lua    symbolizer.SymbolizerConfig `yaml:"lua"`
 }
 
 // FeatureFlagsConfig holds agent-side [feature-flags](https://trunkbaseddevelopment.com/feature-flags/)

perforator/agent/collector/pkg/profiler/profiler.go

@@ -402,7 +402,7 @@ func (p *Profiler) initialize(r metrics.Registry) (err error) {
 		p.log.Error("SPAR: profiler::initialize -> enabled != nil && *enabled -> true")
 
 		p.log.Info("SSE4: Lua is enabled, creating Lua Symbolizer")
-		p.luaSymbolizer, err = symbolizer.NewLuaSymbolizer(&p.conf.Symbolizer.Php, p.bpf, r)
+		p.luaSymbolizer, err = symbolizer.NewLuaSymbolizer(&p.conf.Symbolizer.Lua, p.bpf, r)
 		if err != nil {
 			return err
 		}

perforator/agent/collector/pkg/profiler/sample_consumer.go

@@ -499,14 +499,13 @@ func (c *oneShotSampleConsumer) collectStacksInto(ctx context.Context, builder *
 	}
 
 	if enableLua := c.p.conf.BPF.TraceLua; enableLua != nil && *enableLua {
+		c.p.log.Error("SPAR: sample_consumer::collectStacksInto -> enableLua != nil && *enableLua -> true", log.Any("LuaStack", c.sample.LuaStack), log.Any("luaMetrics", c.p.metrics.luaMetrics))
 		c.collectInterpreterStackInto(
 			&c.p.metrics.luaMetrics,
 			builder,
 			c.luaProcessor,
 			&c.sample.LuaStack,
 		)
-
-		c.p.log.Error("SPAR: sample_consumer::collectStacksInto -> enableLua != nil && *enableLua -> true", log.Any("LuaStack", c.sample.LuaStack), log.Any("luaMetrics", c.p.metrics.luaMetrics))
 		c.p.log.Info("SSE4: Lua is enabled, collect Lua Interpreter stack info")
 	} else {
 		c.p.log.Error("SPAR: sample_consumer::collectStacksInto -> enableLua != nil && *enableLua -> false")
@@ -618,6 +617,7 @@ func (c *oneShotSampleConsumer) recordSample(ctx context.Context) {
 
 // On CPU / perf event profiling.
 func (c *oneShotSampleConsumer) recordCPUSample(ctx context.Context) {
+	println("SPAR: recordCPUSample")
 	hasWallTime := c.p.conf.BPF.TraceWallTime != nil && *c.p.conf.BPF.TraceWallTime
 
 	sampleTypes := []profile.SampleType{{Kind: "cpu", Unit: "cycles"}}

perforator/agent/collector/pkg/profiler/stack_processor.go

@@ -1,10 +1,10 @@
 package profiler
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/yandex/perforator/perforator/agent/collector/pkg/profile"
-	lua_models "github.com/yandex/perforator/perforator/internal/linguist/lua/models"
 	"github.com/yandex/perforator/perforator/internal/linguist/models"
 	python_models "github.com/yandex/perforator/perforator/internal/linguist/python/models"
 	"github.com/yandex/perforator/perforator/internal/linguist/symbolizer"
@@ -45,6 +45,7 @@ func newLuaSampleStackProcessor(symbolizer *symbolizer.Symbolizer) *sampleStackP
 }
 
 func (s *sampleStackProcessor) Process(builder *profile.SampleBuilder, stack *unwinder.InterpreterStack) interpreterStackMetrics {
+	println("SPAR: stack_processor::Process")
 	processFrame := s.getFrameProcessor()
 	mtr := interpreterStackMetrics{}
 
@@ -64,9 +65,11 @@ func (s *sampleStackProcessor) Process(builder *profile.SampleBuilder, stack *un
 }
 
 func processFrameCommon(s *sampleStackProcessor, mtr *interpreterStackMetrics, loc *profile.LocationBuilder, frame *unwinder.InterpreterFrame) {
+	println("SPAR: stack_processor::processFrameCommon")
 	symbol, exists := s.interpreterSymbolizer.Symbolize(&frame.SymbolKey)
 	if !exists {
 		mtr.unsymbolizedFramesCount++
+
 		loc.AddFrame().
 			SetName(models.UnsymbolizedInterpreterLocation).
 			SetStartLine(int64(frame.SymbolKey.Linestart)).
@@ -83,6 +86,7 @@ func processFrameCommon(s *sampleStackProcessor, mtr *interpreterStackMetrics, l
 
 func processPythonFrame(s *sampleStackProcessor, mtr *interpreterStackMetrics, loc *profile.LocationBuilder, frame *unwinder.InterpreterFrame) {
 	loc.SetMapping().SetPath(string(s.langMapping)).Finish()
+
 	if frame.SymbolKey.Linestart == -1 {
 		loc.AddFrame().SetName(python_models.PythonTrampolineFrame).Finish()
 		return
@@ -320,21 +324,8 @@ var ffnames = []string{
 	"buffer.decode",
 }
 
-// see lj_frame.h
-var ftsz = []string{
-	"LUA",
-	"C",
-	"CONT",
-	"VARG",
-	"LUAP",
-	"CP",
-	"PCALL",
-	"PCALLH",
-}
-
 // internal frame decoding errors, see LuaUnwindError at perforator/agent/collector/progs/unwinder/lua/types.h
 var frame_decoding_errors = []string{
-	"",
 	"frame is null",
 	"gc func is null",
 	"bad frame function",
@@ -369,62 +360,131 @@ var entities = []string{
 	"upvalue",
 }
 
+type LuaData struct {
+	frame *unwinder.InterpreterFrame
+}
+
+const (
+	LuaPointerMask    = 0xFFFFFFFFFFFF
+	LuaPointerBitSize = 48
+
+	LuaContextTypeMask = 0x7
+
+	LuaFfidMask    = 0xFF
+	LuaFfidLua     = 0
+	LuaFfidC       = 1
+	LuaFfidInvalid = -1
+
+	LuaUnwindErrorMask    = 0x3
+	LuaUnwindErrorBitSize = 2
+
+	LuaFrameGctMask = 0xF
+
+	LuaLineStartNotUsed = -1
+)
+
+func (ld *LuaData) getObjectAddress() uint64 {
+	return ld.frame.SymbolKey.ObjectAddr
+}
+
+func (ld *LuaData) GetLineStart() int32 {
+	return ld.frame.SymbolKey.Linestart
+}
+
+func (ld *LuaData) GetFrameType() int {
+	if ld.GetLineStart() != LuaLineStartNotUsed {
+		return LuaFfidLua
+	} else if ld.getObjectAddress() == 0 {
+		return LuaFfidInvalid
+	}
+
+	return int(ld.GetFfid())
+}
+
+func (ld *LuaData) GetPtr() uint64 {
+	return ld.getObjectAddress() & LuaPointerMask
+}
+
+func (ld *LuaData) GetContextType() unwinder.LuaContextType {
+	return unwinder.LuaContextType((ld.getObjectAddress() >> LuaPointerBitSize) & LuaContextTypeMask)
+}
+
+func (ld *LuaData) GetFfid() uint8 {
+	return uint8((ld.getObjectAddress() >> LuaPointerBitSize) & LuaFfidMask)
+}
+
+func (ld *LuaData) GetErrorKind() unwinder.LuaUnwindError {
+	return unwinder.LuaUnwindError((ld.getObjectAddress() >> LuaPointerBitSize) & LuaContextTypeMask)
+}
+
+func (ld *LuaData) GetFrameGct() uint8 {
+	return uint8((ld.getObjectAddress() >> (LuaPointerBitSize + LuaUnwindErrorBitSize)) & LuaFrameGctMask)
+}
+
 func processLuaFrame(s *sampleStackProcessor, mtr *interpreterStackMetrics, loc *profile.LocationBuilder, frame *unwinder.InterpreterFrame) {
+	println("SPAR: stack_processor::processLuaFrame")
 
 	loc.SetMapping().SetPath(string(s.langMapping)).Finish()
+
 	symbol, exists := s.interpreterSymbolizer.Symbolize(&frame.SymbolKey)
+
 	if !exists {
 		mtr.unsymbolizedFramesCount++
+
 		loc.AddFrame().
 			SetName(models.UnsymbolizedInterpreterLocation).
 			SetStartLine(int64(frame.SymbolKey.Linestart)).
 			Finish()
 		return
 	}
+
+	luaData := LuaData{frame}
 	name := symbol.Name
 	filename := symbol.FileName
 
-	if frame.SymbolKey.LuaInvalidFrame != 0 {
-		// Invalid frame, wasn't decoded as Lua function
+	switch luaData.GetFrameType() {
+	case LuaFfidInvalid:
+		// Invalid frame
 		name = "<Invalid Lua Frame>"
-		if int(frame.SymbolKey.LuaGct) < len(gct) {
-			name += "#" + gct[frame.SymbolKey.LuaGct]
+
+		if int(luaData.GetFrameGct()) < len(gct) {
+			name += "#" + gct[luaData.GetFrameGct()]
 		}
-		if int(frame.SymbolKey.LuaInvalidFrame) < len(frame_decoding_errors) {
-			name += ": " + frame_decoding_errors[frame.SymbolKey.LuaInvalidFrame]
+
+		if int(luaData.GetErrorKind()) < len(frame_decoding_errors) {
+			name += ": " + frame_decoding_errors[luaData.GetErrorKind()]
 		}
-	} else if frame.SymbolKey.LuaFfid == 0 {
-		// Lua function
-		if frame.SymbolKey.LuaEntity != 0 {
-			name = entities[frame.SymbolKey.LuaEntity] + " " + name
+	case LuaFfidLua:
+		if luaData.GetContextType() != 0 {
+			name = entities[luaData.GetContextType()] + " " + name
 		}
-		name = "[" + ftsz[frame.SymbolKey.LuaFtsz] + "] " + name
 
 		// Usually scripts has @ appended at the beginning.
 		// Perforator has same symbol, removing here.
 		if filename[0] == '@' {
 			filename = symbol.FileName[1:]
 		}
-		filename += ":" + strconv.Itoa(int(frame.SymbolKey.LuaLine))
-	} else if frame.SymbolKey.LuaFfid == 1 {
 
-		// this C function will be automatically symbolized by the native unwinder, no need to emit duplicated frame
-		// nevertheless, adding a native frame into interpreter stack confused merge algorithm (see postprocess.go)
-		name = lua_models.LuaTrampolineFrame
-
-	} else {
-		// interpreter builtin aka fast function (ff)
-		name = "[builtin] " + ffnames[frame.SymbolKey.LuaFfid] + "#" + strconv.Itoa(int(frame.SymbolKey.LuaFfid))
+		filename += ":" + strconv.Itoa(int(frame.SymbolKey.Linestart))
+	case LuaFfidC:
+		// The frame will be symbolized by postprocess
+		name = fmt.Sprintf("function: 0x%x", luaData.GetPtr())
+	default:
+		// The frame will be symbolized by postprocess
+		// If postprocess will fail, at least print its builtin number to find the name manually
+		name = "[builtin] " + ffnames[luaData.GetFfid()] + "#" + strconv.Itoa(int(luaData.GetFfid()))
 	}
+
 	loc.AddFrame().
-		SetName(name).
+		SetName("[lua] " + name).
 		SetFilename(filename).
 		SetStartLine(int64(frame.SymbolKey.Linestart)).
 		Finish()
-
 }
 
 func (s *sampleStackProcessor) getFrameProcessor() func(s *sampleStackProcessor, mtr *interpreterStackMetrics, loc *profile.LocationBuilder, frame *unwinder.InterpreterFrame) {
+	println("SPAR: stack_processor::getFrameProcessor")
+
 	switch s.langMapping {
 	case profile.PythonSpecialMapping:
 		return processPythonFrame

perforator/agent/collector/progs/unwinder/interpreter/types.h

@@ -4,31 +4,6 @@ struct symbol_key {
     u64 object_addr;
     u32 pid;
     i32 linestart;
-    // Lua function ID
-    // FF_LUA = 0: Lua function
-    // FF_C = 1 C: function
-    // everything else: fast function (interpreter builtin)
-    // (think: maybe reuse linestart for FFI, as it's not occupied for FFI?)
-    u8 lua_ffid;
-    /* Frame type markers in LSB of PC (4-byte aligned) or delta (8-byte aligned:
-    **
-    **    PC  00  Lua frame
-    ** delta 001  C frame
-    ** delta 010  Continuation frame
-    ** delta 011  Lua vararg frame
-    ** delta 101  cpcall() frame
-    ** delta 110  ff pcall() frame
-    ** delta 111  ff pcall() frame with active hook
-    */
-    u8 lua_ftsz;
-    // if non-zero, the frame is invalid, and error code is written (see LuaUnwindError)
-    u8 lua_invalid_frame;
-    // see lj_obj.h
-    u8 lua_gct;
-    // BCPos type (think: just write to linestart?)
-    i32 lua_line;
-    // see LuaEntity
-    u8 lua_entity;
 };
 
 enum {

perforator/agent/collector/progs/unwinder/lua/types.h

@@ -78,26 +78,77 @@ enum {
 
 // Keep in sync with frame_decoding_errors @
 // perforator/agent/collector/pkg/profiler/stack_processor.go
-typedef enum {
-    // zero is reserved to indicate successful frame decoding
-    LUA_UNWIND_OK = 0,
+enum lua_unwind_error : u8 {
     LUA_UNWIND_ERROR_FRAME_IS_NULL,
     LUA_UNWIND_ERROR_GCFUNC_IS_NULL,
     LUA_UNWIND_ERROR_FRAME_IS_NOT_FUNC
-} LuaUnwindError;
-
-// actually, there are no true "function names" in lua
-// the name of the function is a name of entity (variable) holding it
-
-typedef enum {
-    LUA_UNKNOWN = 0,
-    LUA_METAMETHOD,
-    LUA_LOCAL,
-    LUA_GLOBAL,
-    LUA_METHOD,
-    LUA_FIELD,
-    LUA_UPVALUE,
-} LuaEntity;
+};
+
+/**
+ * @brief
+ *
+ */
+enum lua_context_type : u8 {
+    LUA_CONTEXT_UNKNOWN,
+    LUA_CONTEXT_METAMETHOD,
+    LUA_CONTEXT_LOCAL,
+    LUA_CONTEXT_GLOBAL,
+    LUA_CONTEXT_METHOD,
+    LUA_CONTEXT_FIELD,
+    LUA_CONTEXT_UPVALUE,
+};
+
+/**
+ * @brief Tagged pointer union for lua frames
+ * In canonical form in most architectures user space addresses are 48 bits
+ * long.
+ * This allows to store additional data in upper 16 bits.
+ *
+ *               |-------------MSW--------------.--------------LSW-------------|
+ * Raw           |-----------------------------u64-----------------------------|
+ *
+ *               |64-51|---50-48---|-------------------47-0--------------------|
+ * Lua frame     |0...0|---ctx_t---|-------------------proto-------------------|
+ *
+ *               |64-56|---55-48---|-------------------47-0--------------------|
+ * C or FF frame |0...0|---ffid----|-------------------addr--------------------|
+ *
+ *               |64-54|53-50|49-48|-------------------47-0--------------------|
+ * Invalid frame |0...0|-gct-|-err-|0.........................................0|
+ */
+union lua_symbol_key_data {
+    struct {
+        u64 ptr : 48; // User-space pointer, not necessarily aligned as function
+                      // pointer. Takes 0-47 bits.
+        union {
+            struct {
+                // Origin of the call like global/local/upvalue.
+                enum lua_context_type context_type : 3;
+            } lua_frame_data; // Lua frame info. Takes 48-50 bits.
+            struct {
+                u8 ffid; // ID of FF function. 1 = Regular C function.
+                // See isffunc@lj_obj.h
+            } c_frame_data; // C or FF frame info. Takes 48-55 bits.
+            struct {
+                enum lua_unwind_error error_kind : 2; // Encountered error type
+                u8 frame_gct : 4; // The GC type of this frame
+            } invalid_frame_data; // Invalid frame info. Takes 48-53 bits.
+        };
+    } lua_data; // Tagged pointer with lua frame info
+    u64 raw;    // Raw 64-bit value
+};
+
+BTF_EXPORT(enum lua_context_type);
+BTF_EXPORT(enum lua_unwind_error);
+
+_Static_assert(LJ_ARCH_ENDIAN == LUAJIT_LE); // TODO: We currently support little-endian architectures only
+_Static_assert(sizeof(union lua_symbol_key_data) ==
+                   sizeof(((struct symbol_key *)0)->object_addr),
+               "Union must match the size of struct symbol_key::object_addr");
+
+// Lua functions do have line information in the range [0; 0x7fffff00).
+// Using -1 as indication of C, FF or invalid frame.
+static const i32 lua_line_start_not_used = -1;
 
 struct lua_config {
     u32 version; // Version of LuaJIT. Encoded as (minor << 8) + (major << 16).