kumi 0.0.14 → 0.0.16

data/lib/kumi/runtime/executable.rb

@@ -37,40 +37,45 @@ module Kumi
     # - DEBUG_VM_ARGS=1 to trace VM execution
     # - Accessors can be debugged independently with DEBUG_ACCESSOR_OPS=1
     class Executable
-      def self.from_analysis(state, registry: nil)
+      def self.from_analysis(state, registry: nil, schema_name: nil)
         ir = state.fetch(:ir_module)
         access_plans = state.fetch(:access_plans)
         input_metadata = state[:input_metadata] || {}
         dependents = state[:dependents] || {}
-        accessors = Kumi::Core::Compiler::AccessBuilder.build(access_plans)
+        schedules = state[:ir_execution_schedules] || {}
+
+        accessors = Dev::Profiler.phase("compiler.access_builder") do
+          Kumi::Core::Compiler::AccessBuilder.build(access_plans)
+        end
 
         access_meta = {}
-        field_to_plan_ids = Hash.new { |h, k| h[k] = [] }
 
-        access_plans.each_value do |plans|
-          plans.each do |p|
-            access_meta[p.accessor_key] = { mode: p.mode, scope: p.scope }
+        # access_plans.each_value do |plans|
+        #   plans.each do |p|
+        #     access_meta[p.accessor_key] = { mode: p.mode, scope: p.scope }
 
-            # Build precise field -> plan_ids mapping for invalidation
-            root_field = p.accessor_key.to_s.split(":").first.split(".").first.to_sym
-            field_to_plan_ids[root_field] << p.accessor_key
-          end
-        end
+        #     # Build precise field -> plan_ids mapping for invalidation
+        #     root_field = p.accessor_key.to_s.split(":").first.split(".").first.to_sym
+        #     field_to_plan_ids[root_field] << p.accessor_key
+        #   end
+        # end
 
         # Use the internal functions hash that VM expects
         registry ||= Kumi::Registry.functions
         new(ir: ir, accessors: accessors, access_meta: access_meta, registry: registry,
-            input_metadata: input_metadata, field_to_plan_ids: field_to_plan_ids, dependents: dependents)
+            input_metadata: input_metadata, dependents: dependents,
+            schema_name: schema_name, schedules: schedules)
       end
 
-      def initialize(ir:, accessors:, access_meta:, registry:, input_metadata:, field_to_plan_ids: {}, dependents: {})
+      def initialize(ir:, accessors:, access_meta:, registry:, input_metadata:, dependents: {}, schedules: {}, schema_name: nil)
         @ir = ir.freeze
         @acc = accessors.freeze
         @meta = access_meta.freeze
         @reg = registry
         @input_metadata = input_metadata.freeze
-        @field_to_plan_ids = field_to_plan_ids.freeze
         @dependents = dependents.freeze
+        @schema_name = schema_name
+        @schedules = schedules
         @decl = @ir.decls.map { |d| [d.name, d] }.to_h
         @accessor_cache = {} # Persistent accessor cache across evaluations
       end
@@ -78,7 +83,7 @@ module Kumi
       def decl?(name) = @decl.key?(name)
 
       def read(input, mode: :ruby)
-        Run.new(self, input, mode: mode, input_metadata: @input_metadata, dependents: @dependents)
+        Run.new(self, input, mode: mode, input_metadata: @input_metadata, dependents: @dependents, declarations: @decl.keys)
       end
 
       # API compatibility for backward compatibility
@@ -93,26 +98,24 @@ module Kumi
         end
       end
 
-      def eval_decl(name, input, mode: :ruby, declaration_cache: nil)
+      def eval_decl(name, input, mode: :ruby, declaration_cache: {})
         raise Kumi::Core::Errors::RuntimeError, "unknown decl #{name}" unless decl?(name)
 
-        vm_context = { 
-          input: input, 
-          target: name, 
+        schedule = @schedules[name]
+        # If the caller asked for a specific binding, schedule deps once
+
+        runtime = {
           accessor_cache: @accessor_cache,
-          declaration_cache: declaration_cache
+          declaration_cache: declaration_cache, # run-local cache
+          schema_name: @schema_name,
+          target: name
         }
-        
-        out = Kumi::Core::IR::ExecutionEngine.run(@ir, vm_context, accessors: @acc, registry: @reg).fetch(name)
 
-        mode == :ruby ? unwrap(@decl[name], out) : out
-      end
+        out = Dev::Profiler.phase("vm.run", target: name) do
+          Kumi::Core::IR::ExecutionEngine.run(schedule, input: input, runtime: runtime, accessors: @acc, registry: @reg).fetch(name)
+        end
 
-      def clear_field_accessor_cache(field_name)
-        # Use precise field -> plan_ids mapping for exact invalidation
-        plan_ids = @field_to_plan_ids[field_name] || []
-        # Cache keys are [plan_id, input_object_id] arrays
-        @accessor_cache.delete_if { |(pid, _), _| plan_ids.include?(pid) }
+        mode == :ruby ? unwrap(@decl[name], out) : out
       end
 
       def unwrap(_decl, v)
@@ -128,129 +131,5 @@ module Kumi
         raise Kumi::Errors::RuntimeError, "No binding named #{unknown_keys.first}"
       end
     end
-
-    class Run
-      def initialize(program, input, mode:, input_metadata:, dependents:)
-        @program = program
-        @input = input
-        @mode = mode
-        @input_metadata = input_metadata
-        @dependents = dependents
-        @cache = {}
-      end
-
-      def get(name)
-        unless @cache.key?(name)
-          # Get the result in VM internal format
-          vm_result = @program.eval_decl(name, @input, mode: :wrapped, declaration_cache: @cache)
-          # Store VM format for cross-VM caching
-          @cache[name] = vm_result
-        end
-        
-        # Convert to requested format when returning
-        vm_result = @cache[name]
-        @mode == :wrapped ? vm_result : @program.unwrap(nil, vm_result)
-      end
-
-      def [](name)
-        get(name)
-      end
-
-      def slice(*keys)
-        return {} if keys.empty?
-
-        keys.each_with_object({}) { |key, result| result[key] = get(key) }
-      end
-
-      def compiled_schema
-        @program
-      end
-
-      def method_missing(sym, *args, **kwargs, &)
-        return super unless args.empty? && kwargs.empty? && @program.decl?(sym)
-
-        get(sym)
-      end
-
-      def respond_to_missing?(sym, priv = false)
-        @program.decl?(sym) || super
-      end
-
-      def update(**changes)
-        affected_declarations = Set.new
-
-        changes.each do |field, value|
-          # Validate field exists
-          raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
-
-          # Validate domain constraints
-          validate_domain_constraint(field, value)
-
-          # Update the input data IN-PLACE to preserve object_id for cache keys
-          @input[field] = value
-
-          # Clear accessor cache for this specific field
-          @program.clear_field_accessor_cache(field)
-
-          # Collect all declarations that depend on this input field
-          field_dependents = @dependents[field] || []
-          affected_declarations.merge(field_dependents)
-        end
-
-        # Only clear cache for affected declarations, not all declarations
-        affected_declarations.each { |decl| @cache.delete(decl) }
-
-        self
-      end
-
-      def wrapped!
-        @mode = :wrapped
-        @cache.clear
-        self
-      end
-
-      def ruby!
-        @mode = :ruby
-        @cache.clear
-        self
-      end
-
-      private
-
-      def input_field_exists?(field)
-        # Check if field is declared in input block
-        @input_metadata.key?(field) || @input.key?(field)
-      end
-
-      def validate_domain_constraint(field, value)
-        field_meta = @input_metadata[field]
-        return unless field_meta&.dig(:domain)
-
-        domain = field_meta[:domain]
-        return unless violates_domain?(value, domain)
-
-        raise ArgumentError, "value #{value} is not in domain #{domain}"
-      end
-
-      def violates_domain?(value, domain)
-        case domain
-        when Range
-          !domain.include?(value)
-        when Array
-          !domain.include?(value)
-        when Proc
-          # For Proc domains, we can't statically analyze
-          false
-        else
-          false
-        end
-      end
-
-      def deep_merge(a, b)
-        return b unless a.is_a?(Hash) && b.is_a?(Hash)
-
-        a.merge(b) { |_k, v1, v2| deep_merge(v1, v2) }
-      end
-    end
   end
 end

data/lib/kumi/runtime/run.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Runtime
+    class Run
+      def initialize(program, input, mode:, input_metadata:, dependents:, declarations:)
+        @program = program
+        @input = input
+        @mode = mode
+        @input_metadata = input_metadata
+        @declarations = declarations
+        @dependents = dependents
+        @cache = {}
+      end
+
+      def key?(name)
+        @declarations.include? name
+      end
+
+      def get(name)
+        unless @cache.key?(name)
+          # Get the result in VM internal format
+          vm_result = @program.eval_decl(name, @input, mode: :wrapped, declaration_cache: @cache)
+          # Store VM format for cross-VM caching
+          @cache[name] = vm_result
+        end
+
+        # Convert to requested format when returning
+        vm_result = @cache[name]
+        @mode == :wrapped ? vm_result : @program.unwrap(nil, vm_result)
+      end
+
+      def to_h
+        slice(*@declarations)
+      end
+
+      def [](name)
+        get(name)
+      end
+
+      def slice(*keys)
+        return {} if keys.empty?
+
+        keys.each_with_object({}) { |key, result| result[key] = get(key) }
+      end
+
+      def compiled_schema
+        @program
+      end
+
+      def method_missing(sym, *args, **kwargs, &)
+        return super unless args.empty? && kwargs.empty? && key?(sym)
+
+        get(sym)
+      end
+
+      def respond_to_missing?(sym, priv = false)
+        key?(sym) || super
+      end
+
+      def update(**changes)
+        affected_declarations = Set.new
+
+        changes.each do |field, value|
+          raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
+
+          validate_domain_constraint(field, value)
+
+          @input[field] = value
+          if (deps = @dependents[field])
+            deps.each { |d| @cache.delete(d) }
+          end
+        end
+
+        self
+      end
+
+      private
+
+      def input_field_exists?(field)
+        # Check if field is declared in input block
+        @input_metadata.key?(field)
+      end
+
+      def validate_domain_constraint(field, value)
+        field_meta = @input_metadata[field]
+        return unless field_meta&.dig(:domain)
+
+        domain = field_meta[:domain]
+        return unless violates_domain?(value, domain)
+
+        raise ArgumentError, "value #{value} is not in domain #{domain}"
+      end
+
+      def violates_domain?(value, domain)
+        case domain
+        when Range, Array
+          !domain.include?(value)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/kumi/schema.rb

@@ -4,18 +4,12 @@ require "ostruct"
 
 module Kumi
   module Schema
-    attr_reader :__syntax_tree__, :__analyzer_result__, :__compiled_schema__
-
-    Inspector = Struct.new(:syntax_tree, :analyzer_result, :compiled_schema) do
-      def inspect
-        "#<#{self.class} syntax_tree: #{syntax_tree.inspect}, analyzer_result: #{analyzer_result.inspect}, compiled_schema: #{compiled_schema.inspect}>"
-      end
-    end
+    attr_reader :__syntax_tree__, :__analyzer_result__, :__executable__
 
     def from(context)
       # VERY IMPORTANT: This method is overriden on specs in order to use dual mode.
 
-      raise("No schema defined") unless @__compiled_schema__
+      raise("No schema defined") unless @__executable__
 
       # Validate input types and domain constraints
       input_meta = @__analyzer_result__.state[:input_metadata] || {}
@@ -23,11 +17,12 @@ module Kumi
 
       raise Errors::InputValidationError, violations unless violations.empty?
 
-      @__compiled_schema__.read(context, mode: :ruby)
+      # TODO: Lazily start a Runner
+      @__executable__.read(context, mode: :ruby)
     end
 
     def explain(context, *keys)
-      raise("No schema defined") unless @__compiled_schema__
+      raise("No schema defined") unless @__executable__
 
       # Validate input types and domain constraints
       input_meta = @__analyzer_result__.state[:input_metadata] || {}
@@ -49,14 +44,20 @@ module Kumi
     def schema(&)
       # from_location = caller_locations(1, 1).first
       # raise "Called from #{from_location.path}:#{from_location.lineno}"
-      @__syntax_tree__ = Core::RubyParser::Dsl.build_syntax_tree(&).freeze
+      @__syntax_tree__ = Dev::Profiler.phase("frontend.parse") do
+        Core::RubyParser::Dsl.build_syntax_tree(&).freeze
+      end
 
       puts Support::SExpressionPrinter.print(@__syntax_tree__, indent: 2) if ENV["KUMI_DEBUG"] || ENV["KUMI_PRINT_SYNTAX_TREE"]
 
-      @__analyzer_result__ = Analyzer.analyze!(@__syntax_tree__).freeze
-      @__compiled_schema__ = Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__).freeze
+      @__analyzer_result__ = Dev::Profiler.phase("analyzer") do
+        Analyzer.analyze!(@__syntax_tree__).freeze
+      end
+      @__executable__ = Dev::Profiler.phase("compiler") do
+        Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__, schema_name: name).freeze
+      end
 
-      Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
+      nil
     end
 
     def schema_metadata

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.14"
+  VERSION = "0.0.16"
 end

data/lib/kumi.rb

@@ -8,10 +8,12 @@ loader.ignore("#{__dir__}/kumi-cli")
 loader.inflector.inflect(
   "lower_to_ir_pass" => "LowerToIRPass",
   "load_input_cse" => "LoadInputCSE",
+  "ir_dependency_pass" => "IRDependencyPass",
   "vm" => "VM",
   "ir" => "IR",
-  'ir_dump' => 'IRDump',
-  'ir_render' => 'IRRender',
+  "ir_dump" => "IRDump",
+  "ir_render" => "IRRender",
+  "ir_execution_schedule_pass" => "IRExecutionSchedulePass"
 )
 loader.setup
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - André Muta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-21 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -48,10 +48,10 @@ files:
 - docs/compiler_design_principles.md
 - docs/dev/analyzer-debug.md
 - docs/dev/parse-command.md
+- docs/dev/vm-profiling.md
 - docs/development/README.md
 - docs/development/error-reporting.md
 - docs/features/README.md
-- docs/features/analysis-cascade-mutual-exclusion.md
 - docs/features/analysis-type-inference.md
 - docs/features/analysis-unsat-detection.md
 - docs/features/hierarchical-broadcasting.md
@@ -93,6 +93,8 @@ files:
 - lib/kumi/core/analyzer/passes/function_signature_pass.rb
 - lib/kumi/core/analyzer/passes/input_access_planner_pass.rb
 - lib/kumi/core/analyzer/passes/input_collector.rb
+- lib/kumi/core/analyzer/passes/ir_dependency_pass.rb
+- lib/kumi/core/analyzer/passes/ir_execution_schedule_pass.rb
 - lib/kumi/core/analyzer/passes/join_reduce_planning_pass.rb
 - lib/kumi/core/analyzer/passes/load_input_cse.rb
 - lib/kumi/core/analyzer/passes/lower_to_ir_pass.rb
@@ -112,6 +114,12 @@ files:
 - lib/kumi/core/analyzer/structs/input_meta.rb
 - lib/kumi/core/atom_unsat_solver.rb
 - lib/kumi/core/compiler/access_builder.rb
+- lib/kumi/core/compiler/access_codegen.rb
+- lib/kumi/core/compiler/access_emit/base.rb
+- lib/kumi/core/compiler/access_emit/each_indexed.rb
+- lib/kumi/core/compiler/access_emit/materialize.rb
+- lib/kumi/core/compiler/access_emit/ravel.rb
+- lib/kumi/core/compiler/access_emit/read.rb
 - lib/kumi/core/compiler/access_planner.rb
 - lib/kumi/core/compiler/accessors/base.rb
 - lib/kumi/core/compiler/accessors/each_indexed_accessor.rb
@@ -188,8 +196,11 @@ files:
 - lib/kumi/core/types/inference.rb
 - lib/kumi/core/types/normalizer.rb
 - lib/kumi/core/types/validator.rb
+- lib/kumi/dev.rb
 - lib/kumi/dev/ir.rb
 - lib/kumi/dev/parse.rb
+- lib/kumi/dev/profile_aggregator.rb
+- lib/kumi/dev/profile_runner.rb
 - lib/kumi/dev/runner.rb
 - lib/kumi/errors.rb
 - lib/kumi/frontends.rb
@@ -203,6 +214,7 @@ files:
 - lib/kumi/kernels/ruby/vector_struct.rb
 - lib/kumi/registry.rb
 - lib/kumi/runtime/executable.rb
+- lib/kumi/runtime/run.rb
 - lib/kumi/schema.rb
 - lib/kumi/schema_metadata.rb
 - lib/kumi/support/diff.rb

data/docs/features/analysis-cascade-mutual-exclusion.md

@@ -1,89 +0,0 @@
-# Cascade Mutual Exclusion Detection
-
-Analyzes cascade expressions to allow safe recursive patterns when conditions are mutually exclusive.
-
-## Overview
-
-The cascade mutual exclusion detector identifies when all conditions in a cascade expression cannot be true simultaneously, enabling safe mutual recursion patterns that would otherwise be rejected as cycles.
-
-## Core Mechanism
-
-The system performs three-stage analysis:
-
-1. **Conditional Dependency Tracking** - DependencyResolver marks base case dependencies as conditional
-2. **Mutual Exclusion Analysis** - UnsatDetector determines if cascade conditions are mutually exclusive  
-3. **Safe Cycle Detection** - Toposorter allows cycles where all edges are conditional and conditions are mutually exclusive
-
-## Example: Processing Workflow
-
-```ruby
-schema do
-  input do
-    string :operation  # "forward", "reverse", "unknown"
-    integer :value
-  end
-
-  trait :is_forward, input.operation == "forward"
-  trait :is_reverse, input.operation == "reverse"
-
-  # Safe mutual recursion - conditions are mutually exclusive
-  value :forward_processor do
-    on is_forward, input.value * 2        # Direct calculation
-    on is_reverse, reverse_processor + 10  # Delegates to reverse (safe)
-    base "invalid operation"               # Fallback for unknown operations
-  end
-
-  value :reverse_processor do
-    on is_forward, forward_processor - 5   # Delegates to forward (safe)
-    on is_reverse, input.value / 2         # Direct calculation
-    base "invalid operation"               # Fallback for unknown operations
-  end
-end
-```
-
-## Safety Guarantees
-
-**Allowed**: Cycles where conditions are mutually exclusive
-- `is_forward` and `is_reverse` cannot both be true (operation has single value)
-- Each recursion executes exactly one step before hitting direct calculation
-- Bounded recursion with guaranteed termination
-
-**Rejected**: Cycles with overlapping conditions
-```ruby
-# This would be rejected - conditions can overlap
-value :unsafe_cycle do
-  on input.n > 0, "positive"
-  on input.n > 5, "large"  # Both can be true!
-  base fn(:not, unsafe_cycle)
-end
-```
-
-## Implementation Details
-
-### Conditional Dependencies
-Base case dependencies are marked as conditional because they only execute when no explicit conditions match.
-
-### Mutual Exclusion Analysis
-Conditions are analyzed for mutual exclusion:
-- Same field equality comparisons: `field == value1` vs `field == value2`
-- Domain constraints ensuring impossibility
-- All condition pairs must be mutually exclusive
-
-### Metadata Generation
-Analysis results stored in `cascade_metadata` state:
-```ruby
-{
-  condition_traits: [:is_forward, :is_reverse],
-  condition_count: 2,
-  all_mutually_exclusive: true,
-  exclusive_pairs: 1,
-  total_pairs: 1
-}
-```
-
-## Use Cases
-
-- Processing workflows with bidirectional logic
-- State machine fallback patterns  
-- Recursive decision trees with termination conditions
-- Complex business rules with safe delegation patterns