kumi 0.0.18 → 0.0.20

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        class InputFormSchemaPass < PassBase
+          def run(errors)
+            input_metadata = get_state(:input_metadata)
+            return state unless input_metadata
+
+            form_schema = build_form_schema(input_metadata)
+            state.with(:input_form_schema, form_schema.freeze)
+          end
+
+          private
+
+          def build_form_schema(metadata)
+            metadata.transform_values { |node| node_to_form_field(node) }
+          end
+
+          def node_to_form_field(node)
+            case node.container
+            when :scalar
+              { type: node.type }
+            when :array
+              element = node.children.values.first
+              {
+                type: :array,
+                element: element ? node_to_form_field(element) : nil
+              }
+            when :hash
+              {
+                type: :object,
+                fields: node.children.transform_values { |child| node_to_form_field(child) }
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module Kumi
         # NOTE: This pass extracts actual IR-level dependencies by analyzing :ref operations
         # in the generated IR, providing the dependency information needed for optimized VM scheduling.
         class IRDependencyPass < PassBase
-          def run(errors)
+          def run(_errors)
             ir_module = get_state(:ir_module, required: true)
 
             ir_dependencies = build_ir_dependency_map(ir_module)

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

@@ -6,7 +6,7 @@ module Kumi
       module Passes
         # PRODUCES: :execution_schedules => { store_name(Symbol) => [Decl, ...] }
         class IRExecutionSchedulePass < PassBase
-          def run(errors)
+          def run(_errors)
             ir          = get_state(:ir_module, required: true)
             deps        = get_state(:ir_dependencies, required: true)    # decl_name => [binding_name, ...]
             name_index  = get_state(:ir_name_index, required: true)      # binding_name => Decl  (← use IR-specific index)

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

@@ -92,30 +92,30 @@ module Kumi
             scope_plans.each do |name, scope_plan|
               # Skip if already processed
               next if plans.key?(name)
-              
+
               # Skip if no vectorized target scope
               next unless scope_plan.scope && !scope_plan.scope.empty?
-              
+
               # Skip if already vectorized (handled above)
               next if vectorized_ops.key?(name)
-              
+
               # Check if this scalar declaration needs broadcasting
-              if needs_scalar_to_vector_broadcast?(name, scope_plan, declarations, vectorized_ops)
-                debug_scalar_broadcast(name, scope_plan) if ENV["DEBUG_JOIN_REDUCE"]
-                
-                plan = Join.new(
-                  policy: :broadcast, # Use broadcast policy for scalar-to-vector
-                  target_scope: scope_plan.scope
-                )
+              next unless needs_scalar_to_vector_broadcast?(name, scope_plan, declarations, vectorized_ops)
 
-                plans[name] = plan
+              debug_scalar_broadcast(name, scope_plan) if ENV["DEBUG_JOIN_REDUCE"]
 
-                debug_join_plan(name, plan) if ENV["DEBUG_JOIN_REDUCE"]
-              end
+              plan = Join.new(
+                policy: :broadcast, # Use broadcast policy for scalar-to-vector
+                target_scope: scope_plan.scope
+              )
+
+              plans[name] = plan
+
+              debug_join_plan(name, plan) if ENV["DEBUG_JOIN_REDUCE"]
             end
           end
 
-          def get_source_scope(name, reduction_info, scope_plans, declarations, input_metadata)
+          def get_source_scope(_name, reduction_info, _scope_plans, declarations, input_metadata)
             # Always infer from the reduction argument - this is the full dimensional scope
             infer_scope_from_argument(reduction_info[:argument], declarations, input_metadata)
           end
@@ -221,21 +221,19 @@ module Kumi
             dims
           end
 
-          def needs_scalar_to_vector_broadcast?(name, scope_plan, declarations, vectorized_ops)
+          def needs_scalar_to_vector_broadcast?(name, _scope_plan, declarations, vectorized_ops)
             # Check if this scalar declaration is referenced by any vectorized operation
             # that requires it to be broadcast to a vectorized scope
-            
+
             # Look for vectorized operations that reference this declaration
-            vectorized_ops.each do |vec_name, vec_info|
+            vectorized_ops.each do |vec_name, _vec_info|
               vec_decl = declarations[vec_name]
               next unless vec_decl
-              
+
               # Check if this vectorized operation references our scalar declaration
-              if declaration_references?(vec_decl.expression, name)
-                return true
-              end
+              return true if declaration_references?(vec_decl.expression, name)
             end
-            
+
             false
           end
 
@@ -248,7 +246,7 @@ module Kumi
             when Kumi::Syntax::CascadeExpression
               expr.cases.any? do |case_expr|
                 declaration_references?(case_expr.condition, target_name) ||
-                declaration_references?(case_expr.result, target_name)
+                  declaration_references?(case_expr.result, target_name)
               end
             when Kumi::Syntax::ArrayExpression
               expr.elements.any? { |elem| declaration_references?(elem, target_name) }

data/lib/kumi/core/analyzer/passes/lir/constant_propagation_pass.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module LIR
+          # ConstantPropagationPass
+          # --------------------------
+          # This is an intra-block constant propagation pass. It substitutes the
+          # uses of registers that hold a known constant value with the literal
+          # constant itself.
+          #
+          # This pass must run before DeadCodeEliminationPass to be effective. It
+          # doesn't remove the original constant assignments; rather, it makes
+          # them "dead" by removing their uses, allowing a subsequent DCE pass
+          # to clean them up.
+          #
+          # In : state[:lir_module]
+          # Out: state.with(:lir_02_const_prop, ...)
+          class ConstantPropagationPass < PassBase
+            LIR = Kumi::Core::LIR
+
+            def run(_errors)
+              ops_by_decl = get_state(:lir_module)
+              # out = {}
+
+              # ops_by_decl.each do |name, payload|
+              #   out[name] = { operations: optimize_decl(Array(payload[:operations])) }
+              # end
+
+              # TODO: - make it work with new gather/length
+              # out.freeze
+              out = ops_by_decl
+              state.with(:lir_06_const_prop, out).with(:lir_module, out.freeze)
+            end
+
+            private
+
+            def optimize_decl(ops)
+              known_constants = {}
+              new_ops = []
+
+              ops.each do |ins|
+                # --- START OF THE FIX ---
+
+                new_inputs = []
+                new_immediates = []
+
+                # Process inputs, replacing known constants with a placeholder.
+                Array(ins.inputs).each do |input_reg|
+                  if (literal = known_constants[input_reg])
+                    new_inputs << :__immediate_placeholder__
+                    new_immediates << literal
+                  else
+                    new_inputs << input_reg
+                  end
+                end
+
+                # Append any existing immediates after the new ones.
+                new_immediates.concat(Array(ins.immediates))
+
+                modified_ins = ins.dup
+                modified_ins.inputs = new_inputs
+                modified_ins.immediates = new_immediates
+                new_ops << modified_ins
+
+                # --- END OF THE FIX ---
+
+                # Update the map based on the MODIFIED instruction.
+                known_constants.delete(modified_ins.result_register) if modified_ins.result_register
+                if modified_ins.opcode == :Constant && modified_ins.immediates&.first
+                  known_constants[modified_ins.result_register] = modified_ins.immediates.first
+                end
+              end
+
+              new_ops
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/lir/dead_code_elimination_pass.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module LIR
+          # DeadCodeEliminationPass
+          # --------------------------
+          # Removes instructions whose results are never used. This is a critical
+          # cleanup pass that runs after other optimizations (like CSE), which often
+          # leave behind unused variable assignments.
+          #
+          # The algorithm works by performing a backward pass over the instructions
+          # of a declaration, tracking the set of "live" registers at each point.
+          # A register is considered "live" if its value is needed by a future
+          # instruction that has an observable effect on the program's output.
+          #
+          # In : state[:lir_03_cse] (or from fused/initial LIR)
+          # Out: state.with(:lir_03_cse, ...)
+          class DeadCodeEliminationPass < PassBase
+            LIR = Kumi::Core::LIR
+
+            def run(_errors)
+              ops_by_decl =
+                get_state(:lir_module, required: false)
+
+              out = {}
+              ops_by_decl.each do |name, payload|
+                out[name] = { operations: optimize_decl(Array(payload[:operations]), name) }
+              end
+
+              out.freeze
+
+              state.with(:lir_module, out)
+            end
+
+            private
+
+            def optimize_decl(ops, decl_name)
+              debug "[DCE] Optimizing declaration: #{decl_name} (#{ops.size} initial instructions)"
+              debug "=================================================="
+
+              live = Set.new
+              new_ops = []
+
+              ops.reverse_each.with_index do |ins, i|
+                original_index = ops.size - 1 - i
+                debug "\n[DCE] [#{original_index}] Processing: #{ins.inspect}"
+                # debug "[DCE]   Live set before: #{live.to_a.sort.inspect}"
+
+                is_side_effect = ins.side_effect?
+                result_in_live = ins.result_register && live.include?(ins.result_register)
+                is_live = is_side_effect || result_in_live
+
+                if is_live
+                  reason = []
+                  reason << "has side effect" if is_side_effect
+                  reason << "result #{ins.result_register} is live" if result_in_live
+                  debug "[DCE]   -> KEEPING (Reason: #{reason.join('; ')})"
+
+                  new_ops.unshift(ins)
+
+                  if ins.result_register
+                    live.delete(ins.result_register)
+                    debug "[DCE]     - Removing defined reg from live set: #{ins.result_register}"
+                  end
+
+                  Array(ins.inputs).each do |input|
+                    next unless input
+
+                    live.add(input)
+                    debug "[DCE]     + Adding used reg to live set: #{input}"
+                  end
+                  # debug "[DCE]   Live set after:  #{live.to_a.sort.inspect}"
+                else
+                  debug "[DCE]   -> DROPPING (Reason: no side effect and result #{ins.result_register || 'n/a'} is not live)"
+                end
+              end
+
+              debug "\n[DCE] Finished optimizing #{decl_name}."
+              debug "[DCE] Final instruction count: #{new_ops.size} (removed #{ops.size - new_ops.size})"
+              debug "=================================================="
+              new_ops
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/lir/hoist_scalar_references_pass.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        module LIR
+          class HoistScalarReferencesPass < PassBase
+            LIR = Kumi::Core::LIR
+            MAX_PASSES = 10
+
+            def run(_errors)
+              current_ops = get_state(:lir_module)
+
+              MAX_PASSES.times do |pass_num|
+                debug "\n[HOIST] Starting Pass ##{pass_num + 1}"
+                new_ops, changed = run_one_pass(current_ops)
+                return state.with(:lir_module, new_ops.freeze).with(:lir_01_hoist_scalar_references, new_ops) unless changed
+
+                current_ops = new_ops
+              end
+
+              raise "HoistScalarReferencesPass did not converge after #{MAX_PASSES} passes."
+            end
+
+            private
+
+            def run_one_pass(ops_by_decl)
+              changed = false
+              new_ops_by_decl = {}
+
+              ops_by_decl.each do |name, payload|
+                original_ops = Array(payload[:operations])
+                debug "[HOIST] Optimizing declaration: #{name} (#{original_ops.size} initial instructions)"
+                optimized_ops = optimize_decl(original_ops)
+                new_ops_by_decl[name] = { operations: optimized_ops }
+                changed ||= original_ops.size != optimized_ops.size || original_ops != optimized_ops
+              end
+
+              [new_ops_by_decl, changed]
+            end
+
+            def optimize_decl(ops)
+              hoist_in_block(ops)
+            end
+
+            def hoist_in_block(ops, current_depth = 0)
+              new_ops = []
+              i = 0
+              while i < ops.length
+                ins = ops[i]
+
+                if ins.opcode == :LoopStart
+                  loop_id = ins.attributes[:id]
+                  debug_indent = "  " * current_depth
+                  debug "#{debug_indent}[HOIST] > Entering Loop #{loop_id}"
+
+                  end_index = find_matching_loop_end(ops, i)
+                  loop_body = ops[(i + 1)...end_index]
+
+                  optimized_body = hoist_in_block(loop_body, current_depth + 1)
+
+                  debug "#{debug_indent}[HOIST] | Analyzing body of Loop #{loop_id} for hoisting..."
+                  hoisted_ops, remaining_ops = optimized_body.partition do |body_ins|
+                    is_hoistable = is_hoistable_scalar_load?(body_ins)
+                    debug "#{debug_indent}[HOIST]   - Hoisting: #{body_ins.inspect}" if is_hoistable
+                    is_hoistable
+                  end
+
+                  debug "#{debug_indent}[HOIST]   (No hoistable instructions found in this loop)" if hoisted_ops.empty?
+
+                  new_ops.concat(hoisted_ops)
+                  new_ops << ins
+                  new_ops.concat(remaining_ops)
+                  new_ops << ops[end_index]
+
+                  debug "#{debug_indent}[HOIST] < Exiting Loop #{loop_id}"
+                  i = end_index + 1
+                else
+                  new_ops << ins
+                  i += 1
+                end
+              end
+              new_ops
+            end
+
+            def is_hoistable_scalar_load?(ins)
+              ins.opcode == :LoadDeclaration && Array(ins.attributes[:axes]).empty?
+            end
+
+            def find_matching_loop_end(ops, start_index)
+              depth = 1
+              (start_index + 1).upto(ops.length - 1) do |i|
+                opcode = ops[i].opcode
+                depth += 1 if opcode == :LoopStart
+                depth -= 1 if opcode == :LoopEnd
+                return i if depth.zero?
+              end
+              raise "Unbalanced LoopStart at index #{start_index}"
+            end
+
+            # Simple debug helper, assuming a `debug` method might exist on PassBase
+            def debug(msg)
+              # In a real scenario, you might have a logger.
+              # For now, we can just print to stdout if a flag is set.
+              puts msg if ENV["DEBUG"]
+            end
+          end
+        end
+      end
+    end
+  end
+end