kumi 0.0.15 → 0.0.16

data/lib/kumi/runtime/executable.rb

@@ -42,44 +42,40 @@ module Kumi
         access_plans = state.fetch(:access_plans)
         input_metadata = state[:input_metadata] || {}
         dependents = state[:dependents] || {}
-        ir_dependencies = state[:ir_dependencies] || {} # <-- from IR dependency pass
-        name_index = state[:name_index] || {} # <-- from IR dependency pass
+        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,
-            ir_dependencies: ir_dependencies, name_index: name_index, schema_name: schema_name)
+            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: {}, ir_dependencies: {},
-                     name_index: {}, schema_name: nil)
+      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
-        @ir_dependencies = ir_dependencies.freeze # decl -> [stored_bindings_it_references]
-        @name_index = name_index.freeze # store_name -> producing decl
         @schema_name = schema_name
+        @schedules = schedules
         @decl = @ir.decls.map { |d| [d.name, d] }.to_h
         @accessor_cache = {} # Persistent accessor cache across evaluations
       end
@@ -87,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
@@ -102,73 +98,30 @@ 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)
 
+        schedule = @schedules[name]
         # If the caller asked for a specific binding, schedule deps once
-        decls_to_run = topo_closure_for_target(name)
 
-        vm_context = {
-          input: input,
+        runtime = {
           accessor_cache: @accessor_cache,
-          declaration_cache: declaration_cache || {}, # run-local cache
-          decls_to_run: decls_to_run,                # <-- explicit schedule
-          strict_refs: true,                         # <-- refs must be precomputed
-          name_index: @name_index,                   # for error messages, twins, etc.
-          schema_name: @schema_name
+          declaration_cache: declaration_cache, # run-local cache
+          schema_name: @schema_name,
+          target: name
         }
 
         out = Dev::Profiler.phase("vm.run", target: name) do
-          Kumi::Core::IR::ExecutionEngine.run(@ir, vm_context, accessors: @acc, registry: @reg).fetch(name)
+          Kumi::Core::IR::ExecutionEngine.run(schedule, input: input, runtime: runtime, accessors: @acc, registry: @reg).fetch(name)
         end
 
         mode == :ruby ? unwrap(@decl[name], out) : out
       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) }
-      end
-
       def unwrap(_decl, v)
         v[:k] == :scalar ? v[:v] : v # no grouping needed
       end
 
-      def topo_closure_for_target(store_name)
-        target_decl = @name_index[store_name]
-        raise "Unknown target store #{store_name}" unless target_decl
-
-        # DFS collect closure of decl names using pre-computed IR-level dependencies
-        seen = {}
-        order = []
-        visiting = {}
-
-        visit = lambda do |dname|
-          return if seen[dname]
-          raise "Cycle detected in DAG scheduler: #{dname}. Mutual recursion should be caught earlier by UnsatDetector." if visiting[dname]
-
-          visiting[dname] = true
-
-          # Visit declarations that produce the bindings this decl references
-          Array(@ir_dependencies[dname]).each do |ref_binding|
-            # Find which declaration produces this binding
-            producer = @name_index[ref_binding]
-            visit.call(producer.name) if producer
-          end
-
-          visiting.delete(dname)
-          seen[dname] = true
-          order << dname
-        end
-
-        visit.call(target_decl.name)
-
-        # 'order' is postorder; it already yields producers before consumers
-        order.map { |dname| @decl[dname] }
-      end
-
       private
 
       def validate_keys(keys)
@@ -178,111 +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
-
-      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
-    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] || {}
@@ -58,11 +53,11 @@ module Kumi
       @__analyzer_result__ = Dev::Profiler.phase("analyzer") do
         Analyzer.analyze!(@__syntax_tree__).freeze
       end
-      @__compiled_schema__ = Dev::Profiler.phase("compiler") do
-        Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__, schema_name: self.name).freeze
+      @__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.15"
+  VERSION = "0.0.16"
 end

data/lib/kumi.rb

@@ -11,8 +11,9 @@ loader.inflector.inflect(
   "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.15
+  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
@@ -94,6 +94,7 @@ files:
 - 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
@@ -113,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
@@ -207,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