kumi 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc6d1a550925563fbffcc0f4f96e6609d70734dfff031d9e6e2bfd405ecf45f8
-  data.tar.gz: '090999f0550fcd66a79cb3f683b8f27680b5921166267bbdf57dd8c593d3c6fd'
+  metadata.gz: 7af4bdb11ef5da5a25b799cef8387752636a8224634c70656efc203b9d923185
+  data.tar.gz: 4e604513e42dcb8754fab54ead4140d5ca2d8443ae4d0461e62dc3b48bb925d4
 SHA512:
-  metadata.gz: 9c18d000d924168fbef1abcc6a19f59f18af8a82fae6d4d7bb14e475ce5b34032f031a14ae3d20faa8deadf96f7e1da9bb2190fca0251da74d629c38f637c139
-  data.tar.gz: 37f124928afe975bb7138c2856093849b6c15fb23694d77a7a0d1628b2c67f7e262576cb734a522105b8f83253fe112f6cbacc00895ad2daba4212eb7a337384
+  metadata.gz: dcbd93268081ff8f0bcf112101603b180932196b1d6fcb59aae2f363d6bbfe4e9ea07cf3cbe811290222dcd15cdf132ea04f409bea34f81599412f729211a5fa
+  data.tar.gz: 3e0c2e91609e742c2852457b2dd61a114a03b988ae983e0cfb23c9bbf46bc5c6c1714636961ed46b4b9ae924c6a77a79dc0aab9013cadbb73e49d5374f8b8dbc

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [Unreleased]
+
+## [0.0.13] – 2025-08-14
+### Added
+- Runtime performance optimizations for interpreter execution
+- Input load deduplication to cache loaded input values and avoid redundant operations
+- Constant folding optimization to evaluate literal expressions during compilation
+- Accessor memoization with proper cache isolation per input context
+- Selective cache invalidation for incremental updates
+
+### Fixed
+- Cache isolation between different input contexts preventing cross-context pollution
+- Cascade mutual exclusion tests now pass correctly with proper trait evaluation
+- Incremental update performance with targeted cache clearing
+
 ## [0.0.12] – 2025-08-14
 ### Added
 - Hash objects input declarations with `hash :field do ... end` syntax

data/lib/kumi/core/analyzer/passes/lower_to_ir_pass.rb

@@ -379,6 +379,7 @@ module Kumi
               when Syntax::InputReference
                 plan_id = pick_plan_id_for_input([expr.name], access_plans,
                                                  scope_plan: scope_plan, need_indices: need_indices)
+                
                 plans    = access_plans.fetch(expr.name.to_s, [])
                 selected = plans.find { |p| p.accessor_key == plan_id }
                 scope    = selected ? selected.scope : []
@@ -430,6 +431,13 @@ module Kumi
               when Syntax::CallExpression
                 entry = Kumi::Registry.entry(expr.fn_name)
 
+                # Constant folding optimization: evaluate expressions with all literal arguments
+                if can_constant_fold?(expr, entry)
+                  folded_value = constant_fold(expr, entry)
+                  ops << Kumi::Core::IR::Ops.Const(folded_value)
+                  return ops.size - 1
+                end
+
                 if ENV["DEBUG_LOWER"] && has_nested_reducer?(expr)
                   puts "  NESTED_REDUCER_DETECTED in #{expr.fn_name} with req_scope=#{required_scope.inspect}"
                 end
@@ -986,6 +994,31 @@ module Kumi
               end
             end
           end
+
+          # Constant folding optimization helpers
+          def can_constant_fold?(expr, entry)
+            return false unless entry&.fn # Skip if function not found
+            return false if entry.reducer # Skip reducer functions for now
+            return false if expr.args.empty? # Need at least one argument
+            
+            # Check if all arguments are literals
+            expr.args.all? { |arg| arg.is_a?(Syntax::Literal) }
+          end
+
+          def constant_fold(expr, entry)
+            literal_values = expr.args.map(&:value)
+            
+            begin
+              # Call the function with literal values at compile time
+              entry.fn.call(*literal_values)
+            rescue StandardError => e
+              # If constant folding fails, fall back to runtime evaluation
+              # This shouldn't happen with pure functions, but be defensive
+              puts "Constant folding failed for #{expr.fn_name}: #{e.message}" if ENV["DEBUG_LOWER"]
+              raise "Cannot constant fold #{expr.fn_name}: #{e.message}"
+            end
+          end
+
         end
       end
     end

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

@@ -42,7 +42,36 @@ module Kumi
       # - DEBUG_GROUP_ROWS=1 prints grouping decisions during Lift.
       module ExecutionEngine
         def self.run(ir_module, ctx, accessors:, registry:)
-          Interpreter.run(ir_module, ctx, accessors: accessors, registry: registry)
+          # Use persistent accessor cache if available, otherwise create temporary one
+          if ctx[:accessor_cache]
+            # 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)
+          end
+          
+          Interpreter.run(ir_module, ctx, accessors: memoized_accessors, registry: registry)
+        end
+
+        private
+
+        def self.add_persistent_memoization(accessors, cache, input_key)
+          accessors.map do |plan_id, accessor_fn|
+            [plan_id, lambda do |input_data|
+              cache_key = [plan_id, input_key]
+              cache[cache_key] ||= accessor_fn.call(input_data)
+            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

data/lib/kumi/runtime/executable.rb

@@ -62,6 +62,7 @@ module Kumi
         @reg = registry
         @input_metadata = input_metadata.freeze
         @decl = @ir.decls.map { |d| [d.name, d] }.to_h
+        @accessor_cache = {} # Persistent accessor cache across evaluations
       end
 
       def decl?(name) = @decl.key?(name)
@@ -85,12 +86,20 @@ module Kumi
       def eval_decl(name, input, mode: :ruby)
         raise Kumi::Core::Errors::RuntimeError, "unknown decl #{name}" unless decl?(name)
 
-        out = Kumi::Core::IR::ExecutionEngine.run(@ir, { input: input, target: name },
+        out = Kumi::Core::IR::ExecutionEngine.run(@ir, { input: input, target: name, accessor_cache: @accessor_cache },
                                               accessors: @acc, registry: @reg).fetch(name)
 
         mode == :ruby ? unwrap(@decl[name], out) : out
       end
 
+      def clear_field_accessor_cache(field_name)
+        # Clear cache entries for all accessor plans related to this field
+        # Cache keys are now [plan_id, input_key] arrays
+        @accessor_cache.delete_if { |cache_key, _| 
+          cache_key.is_a?(Array) && cache_key[0].to_s.start_with?("#{field_name}:")
+        }
+      end
+
       private
 
       def validate_keys(keys)
@@ -153,9 +162,12 @@ module Kumi
 
           # Update the input data
           @input = deep_merge(@input, { field => value })
+          
+          # Clear accessor cache for this specific field
+          @program.clear_field_accessor_cache(field)
         end
 
-        # Clear cache after all updates
+        # Clear declaration evaluation cache after all updates
         @cache.clear
         self
       end

data/lib/kumi/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - André Muta