konpeito 0.1.0

data/lib/konpeito/codegen/monomorphizer.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Codegen
+    # Monomorphizer generates specialized versions of polymorphic functions
+    # for specific type instantiations.
+    #
+    # Example:
+    #   def identity(x)
+    #     x
+    #   end
+    #
+    #   identity(42)       # generates identity_Integer
+    #   identity("hello")  # generates identity_String
+    #
+    class Monomorphizer
+      attr_reader :specializations, :call_sites, :union_dispatches
+
+      def initialize(hir_program, type_info)
+        @hir_program = hir_program
+        @type_info = type_info  # HMInferrer
+        @specializations = {}   # { [func_name, type_args] => specialized_name }
+        @call_sites = []        # Array of { call: HIR::Call, types: [...] }
+        @union_call_sites = []  # Calls requiring runtime dispatch
+        @union_dispatches = {}  # { [func_name, original_types] => dispatch_info }
+        @generated_functions = {}
+      end
+
+      # Analyze the HIR program to find monomorphization opportunities
+      def analyze
+        @hir_program.functions.each do |func|
+          analyze_function(func)
+        end
+
+        # Determine which specializations to generate
+        determine_specializations
+      end
+
+      # Apply monomorphization transformations
+      def transform
+        # Generate specialized function copies
+        generate_specialized_functions
+
+        # Rewrite call sites to use specialized functions
+        rewrite_call_sites
+      end
+
+      # Get the specialized function name for a call
+      def specialized_name(func_name, arg_types)
+        key = [func_name.to_s, arg_types.map(&:to_s)]
+        @specializations[key]
+      end
+
+      private
+
+      def analyze_function(func)
+        func.body.each do |block|
+          block.instructions.each do |inst|
+            analyze_instruction(inst, func)
+          end
+        end
+      end
+
+      def analyze_instruction(inst, context_func)
+        case inst
+        when HIR::Call
+          analyze_call(inst, context_func)
+        end
+      end
+
+      def analyze_call(call, context_func)
+        # Only specialize self-calls (calls on the same instance)
+        # Cross-class calls like h.add(1, 2) should not be specialized as direct calls
+        return unless self_receiver?(call.receiver)
+
+        # Check if this is a call to a local function that could be specialized
+        target_func = find_function(call.method_name)
+        return unless target_func
+        return if target_func.params.empty?
+
+        # Skip functions with rest params (*args) or keyword_rest (**kwargs)
+        # Rest params collect arguments into an array; specializing by element type is incorrect
+        return if target_func.params.any? { |p| p.rest || p.keyword_rest }
+
+        # Get parameter types from target function (may include Union types from RBS)
+        param_types = target_func.params.map(&:type)
+
+        # Get concrete argument types at this call site
+        arg_types = call.args.map { |arg| get_concrete_type(arg) }
+
+        # Check if any PARAMETER has a Union type (from RBS definition)
+        has_union_param = param_types.any? { |t| union_type?(t) }
+
+        # Also check if any argument has a Union type (from type inference)
+        has_union_arg = arg_types.any? { |t| union_type?(t) }
+
+        if has_union_param || has_union_arg
+          # Use parameter types for expansion (they contain the full Union info)
+          types_to_expand = param_types.each_with_index.map do |param_type, i|
+            if union_type?(param_type)
+              param_type
+            elsif i < arg_types.size && union_type?(arg_types[i])
+              arg_types[i]
+            else
+              arg_types[i] || param_type
+            end
+          end
+
+          # Expand union types into all possible combinations
+          expand_union_types(types_to_expand).each do |concrete_types|
+            @call_sites << {
+              call: call,
+              context: context_func,
+              target: target_func.name,
+              types: concrete_types,
+              union_dispatch: true,
+              original_types: types_to_expand
+            }
+          end
+        else
+          # Skip if any type is still polymorphic
+          return if arg_types.any? { |t| polymorphic_type?(t) }
+
+          @call_sites << {
+            call: call,
+            context: context_func,
+            target: target_func.name,
+            types: arg_types,
+            union_dispatch: false
+          }
+        end
+      end
+
+      # Check if a receiver is self (same instance)
+      # For monomorphization, we must be strict: only SelfRef is considered self
+      def self_receiver?(receiver)
+        receiver.is_a?(HIR::SelfRef)
+      end
+
+      def find_function(name)
+        @hir_program.functions.find { |f| f.name.to_s == name.to_s }
+      end
+
+      def get_concrete_type(hir_value)
+        case hir_value
+        when HIR::Instruction
+          hir_value.type
+        when HIR::Node
+          hir_value.type
+        else
+          TypeChecker::Types::UNTYPED
+        end
+      end
+
+      def polymorphic_type?(type)
+        return true if type.nil?
+        return true if type.is_a?(TypeChecker::Types::Untyped)
+        return true if type.respond_to?(:id) && type.class.name.include?("TypeVar")
+        false
+      end
+
+      # Check if a type is a Union type
+      def union_type?(type)
+        type.is_a?(TypeChecker::Types::Union)
+      end
+
+      # Expand union types into all possible combinations
+      # Example: [Integer, Union[String, Float]] => [[Integer, String], [Integer, Float]]
+      def expand_union_types(types)
+        combinations = [[]]
+        types.each do |type|
+          if union_type?(type)
+            new_combinations = []
+            combinations.each do |combo|
+              type.types.each { |member| new_combinations << (combo + [member]) }
+            end
+            combinations = new_combinations
+          else
+            combinations = combinations.map { |c| c + [type] }
+          end
+        end
+        combinations
+      end
+
+      def determine_specializations
+        # Group call sites by (function, types)
+        grouped = @call_sites.group_by { |cs| [cs[:target], cs[:types]] }
+
+        grouped.each do |(func_name, types), sites|
+          next if types.all? { |t| t == TypeChecker::Types::UNTYPED }
+
+          type_suffix = types.map { |t| type_to_suffix(t) }.join("_")
+          specialized = "#{func_name}_#{type_suffix}"
+
+          key = [func_name.to_s, types.map(&:to_s)]
+          @specializations[key] = specialized
+
+          # Track if this came from union expansion
+          if sites.any? { |s| s[:union_dispatch] }
+            @union_call_sites << {
+              call: sites.first[:call],
+              target: func_name,
+              original_types: sites.first[:original_types],
+              concrete_types: types,
+              specialized_name: specialized
+            }
+          end
+        end
+
+        # Group union call sites by original call
+        consolidate_union_dispatches
+      end
+
+      # Group union call sites by their original (pre-expansion) call
+      def consolidate_union_dispatches
+        @union_dispatches = {}
+
+        # Group by (target, original_types)
+        grouped = @union_call_sites.group_by { |s| [s[:target], s[:original_types].map(&:to_s)] }
+
+        grouped.each do |(target, original_type_strs), sites|
+          # Build a mapping from concrete types to specialized function names
+          specializations = {}
+          sites.each do |site|
+            concrete_key = site[:concrete_types].map(&:to_s)
+            specializations[concrete_key] = site[:specialized_name]
+          end
+
+          # Find union positions (which argument indices have Union types)
+          original_types = sites.first[:original_types]
+          union_positions = original_types.each_with_index
+            .select { |t, _i| union_type?(t) }
+            .map { |_, i| i }
+
+          key = [target.to_s, original_type_strs]
+          @union_dispatches[key] = {
+            call: sites.first[:call],
+            target: target,
+            original_types: original_types,
+            union_positions: union_positions,
+            specializations: specializations
+          }
+        end
+      end
+
+      def type_to_suffix(type)
+        case type
+        when TypeChecker::Types::ClassInstance
+          type.name.to_s
+        when TypeChecker::Types::NilType
+          "Nil"
+        when TypeChecker::Types::BoolType
+          "Bool"
+        else
+          type.to_s.gsub(/[^a-zA-Z0-9]/, "_")
+        end
+      end
+
+      def generate_specialized_functions
+        @specializations.each do |(func_name, type_strs), specialized_name|
+          original = find_function(func_name)
+          next unless original
+
+          # Parse type strings back to types (for comparison in call sites)
+          types = @call_sites
+            .find { |cs| cs[:target].to_s == func_name && cs[:types].map(&:to_s) == type_strs }
+            &.dig(:types)
+          next unless types
+
+          specialized = clone_function(original, specialized_name, types)
+          @generated_functions[specialized_name] = specialized
+          @hir_program.functions << specialized
+        end
+      end
+
+      def clone_function(original, new_name, param_types)
+        # Create specialized parameter list with concrete types
+        specialized_params = original.params.each_with_index.map do |param, i|
+          HIR::Param.new(
+            name: param.name,
+            type: param_types[i] || param.type,
+            default_value: param.default_value,
+            rest: param.rest,
+            keyword: param.keyword,
+            block: param.block
+          )
+        end
+
+        # Deep clone the body blocks
+        specialized_body = deep_clone_blocks(original.body)
+
+        HIR::Function.new(
+          name: new_name,
+          params: specialized_params,
+          body: specialized_body,
+          return_type: original.return_type,
+          is_instance_method: original.is_instance_method,
+          owner_class: original.owner_class
+        )
+      end
+
+      def deep_clone_blocks(blocks)
+        # Create a simple deep copy of blocks
+        # In a full implementation, we'd update type information throughout
+        blocks.map do |block|
+          new_block = HIR::BasicBlock.new(label: block.label)
+          block.instructions.each do |inst|
+            new_block.add_instruction(clone_instruction(inst))
+          end
+          new_block.set_terminator(clone_terminator(block.terminator)) if block.terminator
+          new_block
+        end
+      end
+
+      def clone_instruction(inst)
+        # Simple shallow clone for now
+        # A full implementation would update types based on specialization
+        inst.dup
+      rescue TypeError
+        # If dup fails, return the original
+        inst
+      end
+
+      def clone_terminator(term)
+        term.dup
+      rescue TypeError
+        term
+      end
+
+      def rewrite_call_sites
+        # Track which calls have already been processed (for Union calls that appear multiple times)
+        processed_calls = Set.new
+
+        @call_sites.each do |site|
+          call = site[:call]
+          next if processed_calls.include?(call.object_id)
+
+          if site[:union_dispatch]
+            # For union dispatch calls, set the dispatch info instead of a single specialized target
+            dispatch_key = [site[:target].to_s, site[:original_types].map(&:to_s)]
+            dispatch_info = @union_dispatches[dispatch_key]
+            if dispatch_info
+              call.instance_variable_set(:@union_dispatch_info, dispatch_info)
+              processed_calls.add(call.object_id)
+            end
+          else
+            # Regular monomorphized call
+            key = [site[:target].to_s, site[:types].map(&:to_s)]
+            specialized_name = @specializations[key]
+            next unless specialized_name
+
+            call.instance_variable_set(:@specialized_target, specialized_name)
+            processed_calls.add(call.object_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/konpeito/codegen/profile_runtime.c

@@ -0,0 +1,341 @@
+/* profile_runtime.c - Konpeito Profiling Runtime
+ *
+ * Thread-safe profiling with minimal overhead.
+ * Uses atomic counters and clock_gettime for timing.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <time.h>
+
+#ifdef __APPLE__
+#include <mach/mach_time.h>
+#endif
+
+/* Maximum number of functions we can profile */
+#define MAX_FUNCTIONS 4096
+
+/* Maximum call stack depth for timing */
+#define MAX_CALL_DEPTH 256
+
+/* Maximum number of unique stack traces for flame graph */
+#define MAX_STACK_SAMPLES 65536
+
+/* Per-function profiling data */
+typedef struct {
+    const char* name;
+    uint64_t call_count;
+    uint64_t total_time_ns;
+} FunctionProfile;
+
+/* Stack sample for flame graph */
+typedef struct {
+    int func_ids[MAX_CALL_DEPTH];
+    int depth;
+    uint64_t time_ns;  /* Time spent at this exact stack */
+} StackSample;
+
+/* Thread-local call stack for timing */
+typedef struct {
+    int func_id;
+    uint64_t entry_time;
+} CallStackEntry;
+
+/* Global profiling state */
+static FunctionProfile g_profiles[MAX_FUNCTIONS];
+static int g_num_functions = 0;
+static char g_output_path[1024] = "konpeito_profile.json";
+static int g_initialized = 0;
+
+/* Flame graph stack samples - stores aggregated time per unique call stack */
+static StackSample g_stack_samples[MAX_STACK_SAMPLES];
+static int g_num_stack_samples = 0;
+
+/* Thread-local storage for call stack */
+static __thread CallStackEntry tls_call_stack[MAX_CALL_DEPTH];
+static __thread int tls_stack_depth = 0;
+static __thread int tls_current_stack[MAX_CALL_DEPTH];  /* Current stack for flame graph */
+
+#ifdef __APPLE__
+static mach_timebase_info_data_t g_timebase_info;
+#endif
+
+/* Get current time in nanoseconds */
+static inline uint64_t get_time_ns(void) {
+#ifdef __APPLE__
+    uint64_t mach_time = mach_absolute_time();
+    return mach_time * g_timebase_info.numer / g_timebase_info.denom;
+#else
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (uint64_t)ts.tv_sec * 1000000000ULL + (uint64_t)ts.tv_nsec;
+#endif
+}
+
+/* Forward declaration */
+void konpeito_profile_finalize(void);
+
+/* Find or create a stack sample for the current call stack */
+static int find_or_create_stack_sample(int* stack, int depth) {
+    /* Search for existing sample with same stack */
+    for (int i = 0; i < g_num_stack_samples; i++) {
+        if (g_stack_samples[i].depth == depth) {
+            int match = 1;
+            for (int j = 0; j < depth; j++) {
+                if (g_stack_samples[i].func_ids[j] != stack[j]) {
+                    match = 0;
+                    break;
+                }
+            }
+            if (match) return i;
+        }
+    }
+
+    /* Create new sample if space available */
+    if (g_num_stack_samples >= MAX_STACK_SAMPLES) return -1;
+
+    int idx = g_num_stack_samples++;
+    g_stack_samples[idx].depth = depth;
+    for (int j = 0; j < depth; j++) {
+        g_stack_samples[idx].func_ids[j] = stack[j];
+    }
+    g_stack_samples[idx].time_ns = 0;
+    return idx;
+}
+
+/* Record time for current stack */
+static void record_stack_time(uint64_t time_ns) {
+    if (tls_stack_depth <= 0) return;
+
+    int idx = find_or_create_stack_sample(tls_current_stack, tls_stack_depth);
+    if (idx >= 0) {
+        g_stack_samples[idx].time_ns += time_ns;
+    }
+}
+
+/* Initialize profiling system */
+void konpeito_profile_init(int num_functions, const char* output_path) {
+    if (g_initialized) return;
+
+    g_num_functions = num_functions < MAX_FUNCTIONS ? num_functions : MAX_FUNCTIONS;
+
+    if (output_path && strlen(output_path) < sizeof(g_output_path)) {
+        strncpy(g_output_path, output_path, sizeof(g_output_path) - 1);
+        g_output_path[sizeof(g_output_path) - 1] = '\0';
+    }
+
+    for (int i = 0; i < MAX_FUNCTIONS; i++) {
+        g_profiles[i].name = NULL;
+        g_profiles[i].call_count = 0;
+        g_profiles[i].total_time_ns = 0;
+    }
+
+#ifdef __APPLE__
+    mach_timebase_info(&g_timebase_info);
+#endif
+
+    g_initialized = 1;
+
+    /* Register atexit handler */
+    atexit(konpeito_profile_finalize);
+}
+
+/* Called at function entry */
+void konpeito_profile_enter(int func_id, const char* func_name) {
+    if (!g_initialized) return;
+    if (func_id < 0 || func_id >= MAX_FUNCTIONS) return;
+    if (tls_stack_depth >= MAX_CALL_DEPTH) return;
+
+    /* Register function name (only first call matters) */
+    if (g_profiles[func_id].name == NULL) {
+        g_profiles[func_id].name = func_name;
+    }
+
+    /* Increment call count */
+    g_profiles[func_id].call_count++;
+
+    /* Push entry onto call stack with timestamp */
+    tls_call_stack[tls_stack_depth].func_id = func_id;
+    tls_call_stack[tls_stack_depth].entry_time = get_time_ns();
+
+    /* Track current stack for flame graph */
+    tls_current_stack[tls_stack_depth] = func_id;
+
+    tls_stack_depth++;
+}
+
+/* Called at function exit */
+void konpeito_profile_exit(int func_id) {
+    if (!g_initialized) return;
+    if (func_id < 0 || func_id >= MAX_FUNCTIONS) return;
+    if (tls_stack_depth <= 0) return;
+
+    /* Calculate elapsed time */
+    uint64_t exit_time = get_time_ns();
+
+    /* Verify we're exiting the right function */
+    if (tls_call_stack[tls_stack_depth - 1].func_id == func_id) {
+        uint64_t elapsed = exit_time - tls_call_stack[tls_stack_depth - 1].entry_time;
+        g_profiles[func_id].total_time_ns += elapsed;
+
+        /* Record time for flame graph at current stack depth */
+        record_stack_time(elapsed);
+    }
+
+    /* Pop from call stack */
+    tls_stack_depth--;
+}
+
+/* Escape string for JSON output */
+static void write_json_string(FILE* fp, const char* str) {
+    fputc('"', fp);
+    while (*str) {
+        switch (*str) {
+            case '"':  fputs("\\\"", fp); break;
+            case '\\': fputs("\\\\", fp); break;
+            case '\n': fputs("\\n", fp); break;
+            case '\r': fputs("\\r", fp); break;
+            case '\t': fputs("\\t", fp); break;
+            default:   fputc(*str, fp); break;
+        }
+        str++;
+    }
+    fputc('"', fp);
+}
+
+/* Write flame graph folded format */
+static void write_flame_graph_folded(void) {
+    /* Generate folded file path */
+    char folded_path[1024];
+    strncpy(folded_path, g_output_path, sizeof(folded_path) - 1);
+    folded_path[sizeof(folded_path) - 1] = '\0';
+
+    /* Replace .json with .folded */
+    char* ext = strstr(folded_path, ".json");
+    if (ext) {
+        strcpy(ext, ".folded");
+    } else {
+        strncat(folded_path, ".folded", sizeof(folded_path) - strlen(folded_path) - 1);
+    }
+
+    FILE* fp = fopen(folded_path, "w");
+    if (!fp) {
+        fprintf(stderr, "Warning: Could not write flame graph to %s\n", folded_path);
+        return;
+    }
+
+    /* Write folded format: func1;func2;func3 samples
+     * Use microseconds as sample count for better granularity */
+    for (int i = 0; i < g_num_stack_samples; i++) {
+        if (g_stack_samples[i].time_ns == 0) continue;
+
+        /* Write stack (semicolon-separated function names) */
+        for (int j = 0; j < g_stack_samples[i].depth; j++) {
+            int func_id = g_stack_samples[i].func_ids[j];
+            const char* name = g_profiles[func_id].name;
+            if (name) {
+                if (j > 0) fputc(';', fp);
+                fputs(name, fp);
+            }
+        }
+
+        /* Write sample count (microseconds) */
+        uint64_t samples = g_stack_samples[i].time_ns / 1000;  /* ns to us */
+        if (samples == 0) samples = 1;  /* At least 1 sample */
+        fprintf(fp, " %llu\n", (unsigned long long)samples);
+    }
+
+    fclose(fp);
+    fprintf(stderr, "Flame graph data written to: %s\n", folded_path);
+    fprintf(stderr, "  Generate SVG with: flamegraph.pl %s > profile.svg\n", folded_path);
+}
+
+/* Finalize and write profile data */
+void konpeito_profile_finalize(void) {
+    if (!g_initialized) return;
+    g_initialized = 0;  /* Prevent double finalization */
+
+    /* Write flame graph folded format */
+    write_flame_graph_folded();
+
+    FILE* fp = fopen(g_output_path, "w");
+    if (!fp) {
+        fprintf(stderr, "Warning: Could not write profile to %s\n", g_output_path);
+        return;
+    }
+
+    /* Calculate total time */
+    uint64_t total_time = 0;
+    for (int i = 0; i < g_num_functions; i++) {
+        if (g_profiles[i].name) {
+            total_time += g_profiles[i].total_time_ns;
+        }
+    }
+
+    /* Write JSON output */
+    fprintf(fp, "{\n  \"functions\": [\n");
+
+    int first = 1;
+    for (int i = 0; i < g_num_functions; i++) {
+        if (g_profiles[i].name == NULL) continue;
+
+        uint64_t calls = g_profiles[i].call_count;
+        uint64_t time_ns = g_profiles[i].total_time_ns;
+        double time_ms = time_ns / 1000000.0;
+        double percent = total_time > 0 ? (time_ns * 100.0 / total_time) : 0.0;
+
+        if (!first) fprintf(fp, ",\n");
+        first = 0;
+
+        fprintf(fp, "    {\n");
+        fprintf(fp, "      \"name\": ");
+        write_json_string(fp, g_profiles[i].name);
+        fprintf(fp, ",\n");
+        fprintf(fp, "      \"calls\": %llu,\n", (unsigned long long)calls);
+        fprintf(fp, "      \"time_ms\": %.3f,\n", time_ms);
+        fprintf(fp, "      \"percent\": %.2f\n", percent);
+        fprintf(fp, "    }");
+    }
+
+    fprintf(fp, "\n  ],\n");
+    fprintf(fp, "  \"total_time_ms\": %.3f\n", total_time / 1000000.0);
+    fprintf(fp, "}\n");
+
+    fclose(fp);
+
+    /* Print summary to stderr */
+    fprintf(stderr, "\n=== Konpeito Profile Summary ===\n");
+    fprintf(stderr, "%-40s %12s %12s %8s\n", "Function", "Calls", "Time (ms)", "%");
+    fprintf(stderr, "%-40s %12s %12s %8s\n",
+            "----------------------------------------",
+            "------------", "------------", "--------");
+
+    for (int i = 0; i < g_num_functions; i++) {
+        if (g_profiles[i].name == NULL) continue;
+
+        uint64_t calls = g_profiles[i].call_count;
+        uint64_t time_ns = g_profiles[i].total_time_ns;
+        double time_ms = time_ns / 1000000.0;
+        double percent = total_time > 0 ? (time_ns * 100.0 / total_time) : 0.0;
+
+        /* Truncate function name if too long */
+        char truncated_name[41];
+        if (strlen(g_profiles[i].name) > 40) {
+            strncpy(truncated_name, g_profiles[i].name, 37);
+            truncated_name[37] = '.';
+            truncated_name[38] = '.';
+            truncated_name[39] = '.';
+            truncated_name[40] = '\0';
+        } else {
+            strncpy(truncated_name, g_profiles[i].name, 40);
+            truncated_name[40] = '\0';
+        }
+
+        fprintf(stderr, "%-40s %12llu %12.3f %7.2f%%\n",
+                truncated_name, (unsigned long long)calls, time_ms, percent);
+    }
+
+    fprintf(stderr, "\nProfile data written to: %s\n", g_output_path);
+}