kumi 0.0.14 → 0.0.15

data/lib/kumi/core/ir/execution_engine/profiler.rb

@@ -3,6 +3,7 @@
 require "json"
 require "fileutils"
 require "time"
+require "set"
 
 module Kumi
   module Core
@@ -11,19 +12,71 @@ module Kumi
         module Profiler
           class << self
             def enabled? = ENV["KUMI_PROFILE"] == "1"
+            def ops_enabled? = ENV.fetch("KUMI_PROFILE_OPS", "1") == "1"
+            def sample_rate = (ENV["KUMI_PROFILE_SAMPLE"]&.to_i || 1)
+            def persistent? = ENV["KUMI_PROFILE_PERSISTENT"] == "1"
+            
+            def set_schema_name(name)
+              @schema_name = name
+              
+              # Ensure profiler is initialized in persistent mode
+              unless @initialized
+                @events = []
+                @meta = {}
+                @file = ENV["KUMI_PROFILE_FILE"] || "tmp/profile.jsonl"
+                @run_id ||= 1
+                @op_seq ||= 0
+                @aggregated_stats ||= Hash.new { |h, k| h[k] = { count: 0, total_ms: 0.0, total_cpu_ms: 0.0, rows: 0, runs: Set.new } }
+                
+                # Truncate file if needed
+                if ENV["KUMI_PROFILE_TRUNCATE"] == "1" && !@persistent_initialized
+                  FileUtils.mkdir_p(File.dirname(@file))
+                  File.write(@file, "")
+                  @aggregated_stats.clear
+                  @persistent_initialized = true
+                end
+                
+                @initialized = true
+              end
+            end
 
             def reset!(meta: {})
+              set_schema_name(meta[:schema_name]) if meta[:schema_name]
               return unless enabled?
-              @events = []
-              @meta   = meta
-              @file   = ENV["KUMI_PROFILE_FILE"] || "tmp/profile.jsonl"
-              @run_id = (@run_id || 0) + 1  # Track run number for averaging
-              @aggregated_stats = (@aggregated_stats || Hash.new { |h, k| h[k] = { count: 0, total_ms: 0.0, total_cpu_ms: 0.0, rows: 0, runs: Set.new } })
               
-              if ENV["KUMI_PROFILE_TRUNCATE"] == "1"
-                FileUtils.mkdir_p(File.dirname(@file))
-                File.write(@file, "")
-                @aggregated_stats.clear  # Clear aggregated stats on truncate
+              # In persistent mode, don't reset aggregated stats or increment run_id
+              # This allows profiling across multiple schema creations
+              if persistent?
+                @events = []
+                @meta = (@meta || {}).merge(meta)
+                @schema_name = meta[:schema_name] if meta[:schema_name]
+                @file = ENV["KUMI_PROFILE_FILE"] || "tmp/profile.jsonl"
+                @run_id ||= 1
+                @op_seq ||= 0
+                @aggregated_stats ||= Hash.new { |h, k| h[k] = { count: 0, total_ms: 0.0, total_cpu_ms: 0.0, rows: 0, runs: Set.new } }
+                
+                # Only truncate on very first reset in persistent mode
+                if ENV["KUMI_PROFILE_TRUNCATE"] == "1" && !@persistent_initialized
+                  FileUtils.mkdir_p(File.dirname(@file))
+                  File.write(@file, "")
+                  @aggregated_stats.clear
+                  @persistent_initialized = true
+                end
+              else
+                # Original behavior: full reset each time
+                @events = []
+                @meta   = meta
+                @schema_name = meta[:schema_name]
+                @file   = ENV["KUMI_PROFILE_FILE"] || "tmp/profile.jsonl"
+                @run_id = (@run_id || 0) + 1
+                @op_seq = 0
+                @aggregated_stats = (@aggregated_stats || Hash.new { |h, k| h[k] = { count: 0, total_ms: 0.0, total_cpu_ms: 0.0, rows: 0, runs: Set.new } })
+                
+                if ENV["KUMI_PROFILE_TRUNCATE"] == "1"
+                  FileUtils.mkdir_p(File.dirname(@file))
+                  File.write(@file, "")
+                  @aggregated_stats.clear
+                end
               end
             end
 
@@ -37,9 +90,54 @@ module Kumi
               Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
             end
 
-            # Per-op record with both wall time and CPU time
-            def record!(decl:, idx:, tag:, op:, t0:, cpu_t0: nil, rows: nil, note: nil)
+            # Phase timing for coarse-grained operations
+            def phase(name, tags = {})
+              return yield unless enabled?
+              p0 = t0; c0 = cpu_t0
+              result = yield
+              wall_ms = (t0 - p0) * 1000.0
+              cpu_ms = (cpu_t0 - c0) * 1000.0
+              stream({
+                ts: Time.now.utc.iso8601(3),
+                kind: "phase",
+                name: name,
+                wall_ms: wall_ms.round(3),
+                cpu_ms: cpu_ms.round(3),
+                tags: tags,
+                run: @run_id
+              })
+              result
+            end
+
+            # Memory snapshot with GC statistics
+            def memory_snapshot(label, extra: {})
               return unless enabled?
+              s = GC.stat
+              stream({
+                ts: Time.now.utc.iso8601(3),
+                kind: "mem",
+                label: label,
+                heap_live: s[:heap_live_slots],
+                old_objects: s[:old_objects],
+                minor_gc: s[:minor_gc_count],
+                major_gc: s[:major_gc_count],
+                rss_mb: read_rss_mb,
+                run: @run_id,
+                **extra
+              })
+            end
+
+            def read_rss_mb
+              ((File.read("/proc/#{$$}/status")[/VmRSS:\s+(\d+)\skB/, 1].to_i) / 1024.0).round(2)
+            rescue
+              nil
+            end
+
+            # Per-op record with both wall time and CPU time (with sampling support)
+            def record!(decl:, idx:, tag:, op:, t0:, cpu_t0: nil, rows: nil, note: nil)
+              return unless enabled? && ops_enabled?
+              @op_seq += 1
+              return unless sample_rate <= 1 || (@op_seq % sample_rate).zero?
               
               wall_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000.0)
               cpu_ms = cpu_t0 ? ((Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - cpu_t0) * 1000.0) : wall_ms
@@ -47,6 +145,7 @@ module Kumi
               ev = {
                 ts:     Time.now.utc.iso8601(3),
                 run:    @run_id,
+                schema: @schema_name,  # schema identifier for multi-schema differentiation
                 decl:   decl,     # decl name (string/symbol)
                 i:      idx,      # op index
                 tag:    tag,      # op tag (symbol)
@@ -172,6 +271,35 @@ module Kumi
               stream({ ts: Time.now.utc.iso8601(3), kind: "summary", data: summary })
             end
 
+            def init_persistent!
+              return unless enabled? && persistent?
+              @persistent_initialized = false
+              reset!
+            end
+
+            def finalize!
+              return unless enabled?
+              
+              # Emit final aggregated summary
+              if @aggregated_stats&.any?
+                stream({
+                  ts: Time.now.utc.iso8601(3),
+                  kind: "final_summary",
+                  data: averaged_analysis
+                })
+              end
+              
+              # Emit cache analysis if available
+              cache_analysis = cache_overhead_analysis
+              if cache_analysis[:cache_operations]&.any?
+                stream({
+                  ts: Time.now.utc.iso8601(3),
+                  kind: "cache_analysis", 
+                  data: cache_analysis
+                })
+              end
+            end
+
             # Stable textual key for "match ops one by one"
             def op_key(decl, idx, tag, op)
               attrs = compact_attrs(op.attrs)

data/lib/kumi/core/ir/execution_engine.rb

@@ -43,15 +43,15 @@ module Kumi
       module ExecutionEngine
         def self.run(ir_module, ctx, accessors:, registry:)
           # Use persistent accessor cache if available, otherwise create temporary one
-          if ctx[:accessor_cache]
+          memoized_accessors = Dev::Profiler.phase("engine.memoization") do
             # Include input data in cache key to avoid cross-context pollution
             input_key = ctx[:input]&.hash || ctx["input"]&.hash || 0
-            memoized_accessors = add_persistent_memoization(accessors, ctx[:accessor_cache], input_key)
-          else
-            memoized_accessors = add_temporary_memoization(accessors)
+            add_persistent_memoization(accessors, ctx[:accessor_cache], input_key)
+          end
+
+          Dev::Profiler.phase("engine.interpreter") do
+            Interpreter.run(ir_module, ctx, accessors: memoized_accessors, registry: registry)
           end
-          
-          Interpreter.run(ir_module, ctx, accessors: memoized_accessors, registry: registry)
         end
 
         private
@@ -64,15 +64,6 @@ module Kumi
             end]
           end.to_h
         end
-
-        def self.add_temporary_memoization(accessors)
-          cache = {}
-          accessors.map do |plan_id, accessor_fn|
-            [plan_id, lambda do |input_data|
-              cache[plan_id] ||= accessor_fn.call(input_data)
-            end]
-          end.to_h
-        end
       end
     end
   end

data/lib/kumi/dev/profile_aggregator.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kumi
+  module Dev
+    class ProfileAggregator
+      attr_reader :events, :phases, :operations, :memory_snapshots, :final_summary
+
+      def initialize(jsonl_file)
+        @jsonl_file = jsonl_file
+        @events = []
+        @phases = []
+        @operations = []
+        @memory_snapshots = []
+        @final_summary = nil
+        load_events
+      end
+
+      def self.load(jsonl_file)
+        new(jsonl_file)
+      end
+
+      # Core aggregation methods
+      def total_execution_time
+        script_phase = phases.find { |p| p["name"] == "script_execution" }
+        script_phase ? script_phase["wall_ms"] : 0
+      end
+
+      def vm_execution_time
+        vm_phases = phases.select { |p| p["name"] == "vm.run" }
+        vm_phases.sum { |p| p["wall_ms"] || 0 }
+      end
+
+      def vm_execution_count
+        phases.count { |p| p["name"] == "vm.run" }
+      end
+
+      def runs_analyzed
+        (operations + phases + memory_snapshots).map { |e| e["run"] }.compact.uniq.sort
+      end
+
+      def schema_breakdown
+        @schema_breakdown ||= operations.group_by { |op| op["schema"] || "Unknown" }.transform_values do |ops|
+          {
+            operations: ops.length,
+            time: ops.sum { |op| op["wall_ms"] || 0 }.round(4),
+            declarations: ops.map { |op| op["decl"] }.uniq.compact.sort
+          }
+        end
+      end
+
+      def operations_by_run
+        operations.group_by { |op| op["run"] }
+      end
+
+      def operation_stats_by_type
+        operations.group_by { |op| op["tag"] }.transform_values do |ops|
+          {
+            count: ops.length,
+            total_ms: ops.sum { |op| op["wall_ms"] || 0 }.round(4),
+            avg_ms: ops.empty? ? 0 : (ops.sum { |op| op["wall_ms"] || 0 } / ops.length).round(6),
+            max_ms: ops.map { |op| op["wall_ms"] || 0 }.max || 0,
+            declarations: ops.map { |op| op["decl"] }.uniq.compact
+          }
+        end.sort_by { |_, stats| -stats[:total_ms] }
+      end
+
+      def operation_stats_by_declaration
+        operations.group_by { |op| op["decl"] }.transform_values do |ops|
+          {
+            count: ops.length,
+            total_ms: ops.sum { |op| op["wall_ms"] || 0 }.round(4),
+            avg_ms: ops.empty? ? 0 : (ops.sum { |op| op["wall_ms"] || 0 } / ops.length).round(6),
+            operation_types: ops.map { |op| op["tag"] }.uniq.compact
+          }
+        end.sort_by { |_, stats| -stats[:total_ms] }
+      end
+
+      def hotspot_analysis(limit: 20)
+        operations.map do |op|
+          {
+            key: "#{op['decl']}@#{op['seq'] || 0}:#{op['tag']}",
+            decl: op["decl"],
+            tag: op["tag"],
+            wall_ms: op["wall_ms"] || 0,
+            cpu_ms: op["cpu_ms"] || 0,
+            rows: op["rows"] || 0
+          }
+        end.group_by { |op| op[:key] }.transform_values do |ops|
+          {
+            count: ops.length,
+            total_ms: ops.sum { |op| op[:wall_ms] }.round(4),
+            avg_ms: ops.empty? ? 0 : (ops.sum { |op| op[:wall_ms] } / ops.length).round(6),
+            decl: ops.first[:decl],
+            tag: ops.first[:tag]
+          }
+        end.sort_by { |_, stats| -stats[:total_ms] }.first(limit)
+      end
+
+      def reference_operation_analysis
+        ref_ops = operations.select { |op| op["tag"] == "ref" }
+        return { operations: 0, total_time: 0, avg_time: 0, by_declaration: [] } if ref_ops.empty?
+
+        {
+          operations: ref_ops.length,
+          total_time: ref_ops.sum { |op| op["wall_ms"] || 0 }.round(4),
+          avg_time: (ref_ops.sum { |op| op["wall_ms"] || 0 } / ref_ops.length).round(6),
+          by_declaration: ref_ops.group_by { |op| op["decl"] }.transform_values do |ops|
+            {
+              count: ops.length,
+              total_ms: ops.sum { |op| op["wall_ms"] || 0 }.round(4),
+              avg_ms: (ops.sum { |op| op["wall_ms"] || 0 } / ops.length).round(6)
+            }
+          end.sort_by { |_, stats| -stats[:total_ms] }
+        }
+      end
+
+      def memory_analysis
+        return nil if memory_snapshots.length < 2
+
+        start_mem = memory_snapshots.first
+        end_mem = memory_snapshots.last
+
+        {
+          start: {
+            heap_live: start_mem["heap_live"],
+            rss_mb: start_mem["rss_mb"],
+            minor_gc: start_mem["minor_gc"],
+            major_gc: start_mem["major_gc"]
+          },
+          end: {
+            heap_live: end_mem["heap_live"],
+            rss_mb: end_mem["rss_mb"],
+            minor_gc: end_mem["minor_gc"],
+            major_gc: end_mem["major_gc"]
+          },
+          growth: {
+            heap_objects: end_mem["heap_live"] - start_mem["heap_live"],
+            heap_growth_pct: ((end_mem["heap_live"] - start_mem["heap_live"]).to_f / start_mem["heap_live"] * 100).round(1),
+            rss_mb: (end_mem["rss_mb"] - start_mem["rss_mb"]).round(2),
+            rss_growth_pct: ((end_mem["rss_mb"] - start_mem["rss_mb"]) / start_mem["rss_mb"] * 100).round(1),
+            minor_gcs: end_mem["minor_gc"] - start_mem["minor_gc"],
+            major_gcs: end_mem["major_gc"] - start_mem["major_gc"]
+          }
+        }
+      end
+
+      def phase_analysis
+        phases.group_by { |p| p["name"] }.transform_values do |phase_events|
+          {
+            count: phase_events.length,
+            total_ms: phase_events.sum { |p| p["wall_ms"] || 0 }.round(4),
+            avg_ms: phase_events.empty? ? 0 : (phase_events.sum { |p| p["wall_ms"] || 0 } / phase_events.length).round(4),
+            max_ms: phase_events.map { |p| p["wall_ms"] || 0 }.max || 0
+          }
+        end.sort_by { |_, stats| -stats[:total_ms] }
+      end
+
+      # Reporting methods
+      def summary_report
+        total_ops = operations.length
+        total_vm_time = vm_execution_time
+        ref_analysis = reference_operation_analysis
+
+        puts "=== PROFILE AGGREGATION SUMMARY ==="
+        puts "Total events: #{events.length}"
+        puts "VM operations: #{total_ops}"
+        puts "VM executions: #{vm_execution_count}"
+        
+        # Schema differentiation
+        schema_stats = schema_breakdown
+        if schema_stats.any? && schema_stats.keys.first != "Unknown"
+          puts "Schemas analyzed: #{schema_stats.keys.join(", ")}"
+          schema_stats.each do |schema, stats|
+            puts "  #{schema}: #{stats[:operations]} operations, #{stats[:time]}ms"
+          end
+        else
+          puts "Schema runs: #{runs_analyzed.length} (runs: #{runs_analyzed.join(', ')})"
+        end
+        
+        puts "Total VM time: #{total_vm_time.round(4)}ms"
+        puts "Average per VM execution: #{vm_execution_count > 0 ? (total_vm_time / vm_execution_count).round(4) : 0}ms"
+        puts
+
+        if ref_analysis[:operations] && ref_analysis[:operations] > 0
+          puts "Reference Operations:"
+          puts "  Count: #{ref_analysis[:operations]} (#{(ref_analysis[:operations].to_f / total_ops * 100).round(1)}% of all ops)"
+          puts "  Time: #{ref_analysis[:total_time]}ms (#{total_vm_time > 0 ? (ref_analysis[:total_time] / total_vm_time * 100).round(1) : 0}% of VM time)"
+          puts "  Avg: #{ref_analysis[:avg_time]}ms per reference"
+        end
+
+        mem = memory_analysis
+        if mem
+          puts
+          puts "Memory Growth:"
+          puts "  Heap: +#{mem[:growth][:heap_objects]} objects (#{mem[:growth][:heap_growth_pct]}%)"
+          puts "  RSS: +#{mem[:growth][:rss_mb]}MB (#{mem[:growth][:rss_growth_pct]}%)"
+          puts "  GC: #{mem[:growth][:minor_gcs]} minor, #{mem[:growth][:major_gcs]} major"
+        end
+      end
+
+      def detailed_report(limit: 15)
+        summary_report
+        puts
+        puts "=== TOP #{limit} HOTSPOTS ==="
+        hotspots = hotspot_analysis(limit: limit)
+        hotspots.each_with_index do |(key, stats), i|
+          puts "#{(i+1).to_s.rjust(2)}. #{key.ljust(40)} #{stats[:total_ms].to_s.rjust(10)}ms (#{stats[:count]} calls, #{stats[:avg_ms]}ms avg)"
+        end
+
+        # Schema breakdown if available
+        schema_stats = schema_breakdown
+        if schema_stats.keys.length > 1 || (schema_stats.keys.first && schema_stats.keys.first != "Unknown")
+          puts
+          puts "=== SCHEMA BREAKDOWN ==="
+          schema_stats.each do |schema, stats|
+            puts "#{schema}:"
+            puts "  Operations: #{stats[:operations]}"
+            puts "  Total time: #{stats[:time]}ms"
+            puts "  Declarations: #{stats[:declarations].join(", ")}"
+            puts
+          end
+        end
+
+        puts "=== OPERATION TYPE BREAKDOWN ==="
+        operation_stats_by_type.each do |op_type, stats|
+          puts "#{op_type.ljust(15)} #{stats[:count].to_s.rjust(8)} calls  #{stats[:total_ms].to_s.rjust(12)}ms  #{stats[:avg_ms].to_s.rjust(10)}ms avg"
+        end
+
+        puts
+        puts "=== TOP #{limit} DECLARATIONS BY TIME ==="
+        operation_stats_by_declaration.first(limit).each do |decl, stats|
+          puts "#{decl.to_s.ljust(35)} #{stats[:count].to_s.rjust(6)} ops  #{stats[:total_ms].to_s.rjust(10)}ms"
+        end
+      end
+
+      def export_summary(filename)
+        summary = {
+          metadata: {
+            total_events: events.length,
+            vm_operations: operations.length,
+            vm_executions: vm_execution_count,
+            analysis_timestamp: Time.now.strftime("%Y-%m-%dT%H:%M:%SZ")
+          },
+          timing: {
+            total_execution_ms: total_execution_time,
+            vm_execution_ms: vm_execution_time,
+            avg_vm_execution_ms: vm_execution_count > 0 ? (vm_execution_time / vm_execution_count).round(4) : 0
+          },
+          operations: {
+            by_type: operation_stats_by_type,
+            by_declaration: operation_stats_by_declaration,
+            hotspots: hotspot_analysis(limit: 20)
+          },
+          references: reference_operation_analysis,
+          memory: memory_analysis,
+          phases: phase_analysis
+        }
+
+        File.write(filename, JSON.pretty_generate(summary))
+        puts "Summary exported to: #{filename}"
+      end
+
+      private
+
+      def load_events
+        return unless File.exist?(@jsonl_file)
+
+        File.readlines(@jsonl_file).each do |line|
+          begin
+            event = JSON.parse(line.strip)
+            next unless event && event.is_a?(Hash)
+
+            @events << event
+
+            case event["kind"]
+            when "phase"
+              @phases << event
+            when "mem"
+              @memory_snapshots << event
+            when "final_summary"
+              @final_summary = event
+            else
+              # VM operations don't have a "kind" field - they have ts, run, decl, i, tag, wall_ms, cpu_ms, etc.
+              # According to profiler.rb line 118-130, VM operations are identified by having decl + tag but no kind
+              if event["decl"] && event["tag"] && !event["kind"]
+                @operations << event
+              elsif event["kind"] && !["summary", "cache_analysis"].include?(event["kind"])
+                # Handle any future event types that have a kind but aren't known
+                @operations << event
+              end
+            end
+          rescue JSON::ParserError
+            # Skip malformed JSON lines
+          end
+        end
+      end
+    end
+  end
+end