ignis 0.0.1

data/lib/nvruby/cuda/graph.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative 'graph_bindings'
+require 'fiddle'
+
+module Ignis
+  module CUDA
+    # CUDA Graph for capturing and replaying GPU operations.
+    # Provides reduced kernel launch overhead for repetitive workloads.
+    #
+    # Uses GraphBindings (FFI-based) since graph operations are NOT hot-path.
+    # Stream handles are Fiddle::Pointer — we convert for FFI interop.
+    class Graph
+      # @return [FFI::Pointer] Native CUDA graph handle
+      attr_reader :handle
+
+      # @return [Boolean] Whether the graph was created via stream capture
+      attr_reader :captured
+
+      # @return [Integer, nil] device_id for recovery coordinator invalidation
+      attr_accessor :device_id
+
+      # Create a new empty CUDA graph.
+      # @param flags [Integer] Graph creation flags (default: 0)
+      def initialize(flags: 0)
+        GraphBindings.ensure_loaded!
+
+        graph_ptr = FFI::MemoryPointer.new(:pointer)
+        status = GraphBindings.cudaGraphCreate(graph_ptr, flags)
+        GraphBindings.check_status!(status, 'cudaGraphCreate')
+
+        @handle = graph_ptr.read_pointer
+        @captured = false
+        @destroyed = false
+        @device_id = nil
+      end
+
+      # Capture GPU operations from a stream into a new graph.
+      # @param stream [Stream, nil] Stream to capture (creates temporary if nil)
+      # @param mode [Symbol] Capture mode (:global, :thread_local, :relaxed)
+      # @yield [Stream] Block containing GPU operations to capture
+      # @return [Graph]
+      def self.capture(stream: nil, mode: :global, &block)
+        GraphBindings.ensure_loaded!
+
+        own_stream = stream.nil?
+        stream ||= Stream.new
+
+        capture_mode = case mode
+                       when :global then GraphBindings::CUDA_STREAM_CAPTURE_MODE_GLOBAL
+                       when :thread_local then GraphBindings::CUDA_STREAM_CAPTURE_MODE_THREAD_LOCAL
+                       when :relaxed then GraphBindings::CUDA_STREAM_CAPTURE_MODE_RELAXED
+                       else GraphBindings::CUDA_STREAM_CAPTURE_MODE_GLOBAL
+                       end
+
+        # Convert Fiddle::Pointer to FFI::Pointer for GraphBindings
+        stream_ffi = to_ffi_ptr(stream.to_ptr)
+
+        status = GraphBindings.cudaStreamBeginCapture(stream_ffi, capture_mode)
+        GraphBindings.check_status!(status, 'cudaStreamBeginCapture')
+
+        begin
+          block.call(stream)
+        ensure
+          graph_ptr = FFI::MemoryPointer.new(:pointer)
+          status = GraphBindings.cudaStreamEndCapture(stream_ffi, graph_ptr)
+          GraphBindings.check_status!(status, 'cudaStreamEndCapture')
+
+          stream.destroy! if own_stream
+        end
+
+        graph = allocate
+        graph.instance_variable_set(:@handle, graph_ptr.read_pointer)
+        graph.instance_variable_set(:@captured, true)
+        graph.instance_variable_set(:@destroyed, false)
+        graph.instance_variable_set(:@device_id, nil)
+
+        graph
+      end
+
+      # Instantiate the graph to create an executable graph.
+      # @param flags [Integer] Instantiation flags
+      # @return [GraphExecutable]
+      def instantiate(flags: 0)
+        raise InvalidOperationError, 'Graph already destroyed' if @destroyed
+
+        GraphExecutable.new(self, flags: flags)
+      end
+
+      # Clone this graph.
+      # @return [Graph]
+      def clone
+        raise InvalidOperationError, 'Graph already destroyed' if @destroyed
+
+        clone_ptr = FFI::MemoryPointer.new(:pointer)
+        status = GraphBindings.cudaGraphClone(clone_ptr, @handle)
+        GraphBindings.check_status!(status, 'cudaGraphClone')
+
+        cloned = Graph.allocate
+        cloned.instance_variable_set(:@handle, clone_ptr.read_pointer)
+        cloned.instance_variable_set(:@captured, @captured)
+        cloned.instance_variable_set(:@destroyed, false)
+        cloned.instance_variable_set(:@device_id, @device_id)
+        cloned
+      end
+
+      # Get number of nodes in the graph.
+      # @return [Integer]
+      def node_count
+        raise InvalidOperationError, 'Graph already destroyed' if @destroyed
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        status = GraphBindings.cudaGraphGetNodes(@handle, FFI::Pointer::NULL, count_ptr)
+        GraphBindings.check_status!(status, 'cudaGraphGetNodes')
+
+        count_ptr.read(:size_t)
+      end
+
+      # Get number of root nodes (nodes with no dependencies).
+      # @return [Integer]
+      def root_node_count
+        raise InvalidOperationError, 'Graph already destroyed' if @destroyed
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        status = GraphBindings.cudaGraphGetRootNodes(@handle, FFI::Pointer::NULL, count_ptr)
+        GraphBindings.check_status!(status, 'cudaGraphGetRootNodes')
+
+        count_ptr.read(:size_t)
+      end
+
+      # @return [Boolean]
+      def destroyed?
+        @destroyed
+      end
+
+      # Destroy the graph and release resources.
+      # @return [void]
+      def destroy!
+        return if @destroyed
+
+        status = GraphBindings.cudaGraphDestroy(@handle)
+        GraphBindings.check_status!(status, 'cudaGraphDestroy')
+
+        @destroyed = true
+        @handle = nil
+      end
+
+      # Convert a Fiddle::Pointer to an FFI::Pointer for interop.
+      # @param fiddle_ptr [Fiddle::Pointer]
+      # @return [FFI::Pointer]
+      def self.to_ffi_ptr(fiddle_ptr)
+        return FFI::Pointer::NULL if fiddle_ptr.nil? || fiddle_ptr.to_i.zero?
+
+        FFI::Pointer.new(:pointer, fiddle_ptr.to_i)
+      end
+    end
+
+    # Executable CUDA Graph ready for launch.
+    class GraphExecutable
+      # @return [FFI::Pointer] Native executable graph handle
+      attr_reader :handle
+
+      # @return [Graph] Source graph
+      attr_reader :source_graph
+
+      # @return [Integer] Number of times this graph has been launched
+      attr_reader :launch_count
+
+      # @param graph [Graph] Source graph
+      # @param flags [Integer] Instantiation flags
+      def initialize(graph, flags: 0)
+        GraphBindings.ensure_loaded!
+
+        exec_ptr = FFI::MemoryPointer.new(:pointer)
+        status = GraphBindings.cudaGraphInstantiate(exec_ptr, graph.handle, flags)
+        GraphBindings.check_status!(status, 'cudaGraphInstantiate')
+
+        @handle = exec_ptr.read_pointer
+        @source_graph = graph
+        @launch_count = 0
+        @destroyed = false
+      end
+
+      # Launch the executable graph.
+      # @param stream [Stream, nil] Stream to launch on (default stream if nil)
+      # @return [self]
+      def launch(stream: nil)
+        raise InvalidOperationError, 'GraphExecutable already destroyed' if @destroyed
+
+        stream_handle = stream ? Graph.to_ffi_ptr(stream.to_ptr) : FFI::Pointer::NULL
+        status = GraphBindings.cudaGraphLaunch(@handle, stream_handle)
+        GraphBindings.check_status!(status, 'cudaGraphLaunch')
+
+        @launch_count += 1
+        self
+      end
+
+      # Upload the graph to the device for faster first launch.
+      # @param stream [Stream, nil]
+      # @return [self]
+      def upload(stream: nil)
+        raise InvalidOperationError, 'GraphExecutable already destroyed' if @destroyed
+
+        stream_handle = stream ? Graph.to_ffi_ptr(stream.to_ptr) : FFI::Pointer::NULL
+        status = GraphBindings.cudaGraphUpload(@handle, stream_handle)
+        GraphBindings.check_status!(status, 'cudaGraphUpload')
+
+        self
+      end
+
+      # Update the executable graph from its source graph.
+      # @return [Boolean] True if update succeeded
+      def update!
+        raise InvalidOperationError, 'GraphExecutable already destroyed' if @destroyed
+
+        result_ptr = FFI::MemoryPointer.new(:int)
+        status = GraphBindings.cudaGraphExecUpdate(@handle, @source_graph.handle, result_ptr)
+
+        status.zero?
+      end
+
+      # @return [Boolean]
+      def destroyed?
+        @destroyed
+      end
+
+      # Destroy the executable graph.
+      # @return [void]
+      def destroy!
+        return if @destroyed
+
+        status = GraphBindings.cudaGraphExecDestroy(@handle)
+        GraphBindings.check_status!(status, 'cudaGraphExecDestroy')
+
+        @destroyed = true
+        @handle = nil
+      end
+    end
+
+    # Convenience module for graph-based operations.
+    module GraphCapture
+      class << self
+        # Capture GPU ops and return executable graph.
+        # @param stream [Stream, nil]
+        # @yield [Stream]
+        # @return [GraphExecutable]
+        def capture(stream: nil, &block)
+          graph = Graph.capture(stream: stream, &block)
+          graph.instantiate
+        end
+
+        # Capture and immediately launch.
+        # @param stream [Stream, nil]
+        # @param repeat [Integer]
+        # @yield [Stream]
+        # @return [GraphExecutable]
+        def capture_and_launch(stream: nil, repeat: 1, &block)
+          exec = capture(stream: stream, &block)
+          repeat.times { exec.launch(stream: stream) }
+          exec
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/cuda/graph_bindings.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module CUDA
+    # CUDA Graphs FFI bindings
+    # Provides stream capture and graph execution for reduced launch overhead
+    module GraphBindings
+      extend FFI::Library
+
+      # CUDA Stream Capture Mode
+      CUDA_STREAM_CAPTURE_MODE_GLOBAL = 0
+      CUDA_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1
+      CUDA_STREAM_CAPTURE_MODE_RELAXED = 2
+
+      # CUDA Graph Instantiate Flags
+      CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = 1
+      CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD = 2
+      CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH = 4
+      CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = 8
+
+      # CUDA Graph Node Types
+      CUDA_GRAPH_NODE_TYPE_KERNEL = 0
+      CUDA_GRAPH_NODE_TYPE_MEMCPY = 1
+      CUDA_GRAPH_NODE_TYPE_MEMSET = 2
+      CUDA_GRAPH_NODE_TYPE_HOST = 3
+      CUDA_GRAPH_NODE_TYPE_GRAPH = 4
+      CUDA_GRAPH_NODE_TYPE_EMPTY = 5
+      CUDA_GRAPH_NODE_TYPE_WAIT_EVENT = 6
+      CUDA_GRAPH_NODE_TYPE_EVENT_RECORD = 7
+
+      @loaded = false
+      @mutex = Mutex.new
+
+      class << self
+        # Ensure CUDA runtime is loaded and graph functions are attached
+        # @return [void]
+        def ensure_loaded!
+          @mutex.synchronize do
+            return if @loaded
+
+            LibraryLoader.load_library(:cuda_runtime)
+
+            # Resolve cudart path per platform
+            dll_path = if defined?(Ignis::Platform)
+                         Ignis::Platform.cudart_path
+                       elsif RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+                         cuda_bin = Ignis.configuration.cuda_bin_path rescue nil
+                         cuda_bin ? Dir.glob(File.join(cuda_bin, 'cudart64_*.dll')).max : 'cudart64_130'
+                       else
+                         'libcudart.so.13'
+                       end
+
+            raise LibraryNotFoundError, 'cudart' unless dll_path
+
+            ffi_lib dll_path
+            attach_graph_functions!
+
+            @loaded = true
+          end
+        end
+
+        # Check status and raise error if not success
+        # @param status [Integer] CUDA error code
+        # @param context [String] Context for error message
+        # @return [void]
+        def check_status!(status, context = "CUDA Graph operation")
+          return if status.zero?
+
+          raise CudaRuntimeError.new("#{context} failed", cuda_code: status)
+        end
+
+        private
+
+        def attach_graph_functions!
+          # Graph creation and destruction
+          attach_function :cudaGraphCreate, [:pointer, :uint], :int
+          attach_function :cudaGraphDestroy, [:pointer], :int
+
+          # Stream capture for graph creation
+          attach_function :cudaStreamBeginCapture, [:pointer, :int], :int
+          attach_function :cudaStreamEndCapture, [:pointer, :pointer], :int
+          attach_function :cudaStreamIsCapturing, [:pointer, :pointer], :int
+
+          # Graph instantiation (create executable graph)
+          attach_function :cudaGraphInstantiate, [:pointer, :pointer, :uint64], :int
+          attach_function :cudaGraphInstantiateWithFlags, [:pointer, :pointer, :uint64], :int
+
+          # Graph execution
+          attach_function :cudaGraphLaunch, [:pointer, :pointer], :int
+
+          # Executable graph destruction
+          attach_function :cudaGraphExecDestroy, [:pointer], :int
+
+          # Graph update (for parameter changes without re-instantiation)
+          attach_function :cudaGraphExecUpdate, [:pointer, :pointer, :pointer], :int
+
+          # Graph node management
+          attach_function :cudaGraphGetNodes, [:pointer, :pointer, :pointer], :int
+          attach_function :cudaGraphGetRootNodes, [:pointer, :pointer, :pointer], :int
+          attach_function :cudaGraphNodeGetType, [:pointer, :pointer], :int
+          attach_function :cudaGraphGetEdges, [:pointer, :pointer, :pointer, :pointer], :int
+
+          # Graph cloning
+          attach_function :cudaGraphClone, [:pointer, :pointer], :int
+
+          # Conditional graph nodes (CUDA 12+)
+          attach_function :cudaGraphAddEmptyNode, [:pointer, :pointer, :pointer, :size_t], :int
+          attach_function :cudaGraphAddDependencies, [:pointer, :pointer, :pointer, :size_t], :int
+          attach_function :cudaGraphRemoveDependencies, [:pointer, :pointer, :pointer, :size_t], :int
+
+          # Graph upload to device (for faster first launch)
+          attach_function :cudaGraphUpload, [:pointer, :pointer], :int
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/cuda/library_loader.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Ignis
+  module CUDA
+    # Handles dynamic loading of NVIDIA CUDA libraries.
+    # Cross-platform: Windows (DLLs via Kernel32) and Linux (.so via dlopen).
+    # Uses Ignis::Platform for path resolution when available.
+    module LibraryLoader
+      # Windows Kernel32 API for DLL search path management (Fiddle-based).
+      # Only loaded on Windows.
+      if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i) || (defined?(Ignis::Platform) && Ignis::Platform.windows?)
+        module Kernel32
+          extend Fiddle::Importer
+          dlload 'kernel32.dll'
+
+          extern 'int SetDllDirectoryW(void*)'
+          extern 'void* AddDllDirectory(void*)'
+        end
+      end
+
+      # Library names and their patterns — resolved per platform.
+      # @return [Hash{Symbol => String}]
+      def self.lib_patterns
+        if defined?(Ignis::Platform)
+          platform_patterns = {}
+          (Ignis::Platform.windows? ? Ignis::Platform::WIN_LIB_PATTERNS : Ignis::Platform::LINUX_LIB_PATTERNS).each do |k, v|
+            platform_patterns[k] = v
+          end
+          platform_patterns
+        elsif RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+          WIN_LIB_PATTERNS
+        else
+          LINUX_LIB_PATTERNS
+        end
+      end
+
+      # Fallback patterns if Platform module not loaded
+      WIN_LIB_PATTERNS = {
+        cuda_runtime: 'cudart64_*.dll',
+        cublas: 'cublas64_*.dll',
+        cublaslt: 'cublasLt64_*.dll',
+        cufft: 'cufft64_*.dll',
+        curand: 'curand64_*.dll',
+        cusparse: 'cusparse64_*.dll',
+        cusolver: 'cusolver64_*.dll',
+        cudnn: 'cudnn64_*.dll',
+        nvrtc: 'nvrtc64_*.dll',
+        cutensor: 'cutensor.dll',
+        cudss: 'cudss64_*.dll',
+        mathdx: 'mathdx64_0.dll',
+        cuda_driver: 'nvcuda.dll'
+      }.freeze
+
+      LINUX_LIB_PATTERNS = {
+        cuda_runtime: 'libcudart.so*',
+        cublas: 'libcublas.so*',
+        cublaslt: 'libcublasLt.so*',
+        cufft: 'libcufft.so*',
+        curand: 'libcurand.so*',
+        cusparse: 'libcusparse.so*',
+        cusolver: 'libcusolver.so*',
+        cudnn: 'libcudnn.so*',
+        nvrtc: 'libnvrtc.so*',
+        cutensor: 'libcutensor.so*',
+        cudss: 'libcudss.so*',
+        mathdx: 'libmathdx.so*',
+        cuda_driver: 'libcuda.so*'
+      }.freeze
+
+      # Custom search paths for additional CUDA libraries
+      def self.custom_paths
+        if defined?(Ignis::Platform)
+          Ignis::Platform.custom_lib_paths
+        elsif windows?
+          {
+            cutensor: 'C:/Program Files/NVIDIA cuTENSOR/v2.4/bin/13',
+            cudss: 'C:/Program Files/NVIDIA cuDSS/v0.7/bin/13'
+          }
+        else
+          {
+            cutensor: '/usr/local/cutensor/lib',
+            cudss: '/usr/local/cudss/lib'
+          }
+        end
+      end
+
+      @loaded_libraries = {}
+      @library_paths = {}
+      @fiddle_handles = {}
+      @mutex = Mutex.new
+      @dll_directory_set = false
+
+      class << self
+        # @return [Hash{Symbol => String}]
+        attr_reader :library_paths
+
+        # @return [Hash{Symbol => Fiddle::Handle}]
+        attr_reader :fiddle_handles
+
+        # @return [Hash{Symbol => String}]
+        def loaded_libraries
+          @mutex.synchronize { @library_paths.dup }
+        end
+
+        # @param library [Symbol]
+        # @return [Boolean]
+        def loaded?(library)
+          @mutex.synchronize { @fiddle_handles.key?(library) }
+        end
+
+        # Load a specific CUDA library via Fiddle::Handle.
+        # @param library [Symbol]
+        # @return [Fiddle::Handle]
+        def load_library(library)
+          @mutex.synchronize do
+            return @fiddle_handles[library] if @fiddle_handles[library]
+
+            ensure_dll_search_path! if windows?
+
+            patterns = lib_patterns
+            pattern = patterns[library]
+            raise ArgumentError, "Unknown library: #{library}" unless pattern
+
+            dll_path = find_library(library, pattern)
+            raise LibraryNotFoundError, library.to_s unless dll_path
+
+            handle = Fiddle::Handle.new(dll_path)
+            @fiddle_handles[library] = handle
+            @library_paths[library] = dll_path
+
+            $stderr.puts "[LibraryLoader] Loaded #{library}: #{dll_path}"
+            handle
+          end
+        end
+
+        # Load all required CUDA libraries.
+        # @param libraries [Array<Symbol>]
+        # @return [Hash{Symbol => Fiddle::Handle}]
+        def load_all(libraries: %i[cuda_runtime cublas cufft curand])
+          libraries.each_with_object({}) do |lib, result|
+            result[lib] = load_library(lib)
+          rescue LibraryNotFoundError => e
+            $stderr.puts "[LibraryLoader] Optional library not found: #{e.message}"
+          end
+        end
+
+        # @return [Fiddle::Handle]
+        def ensure_cuda_runtime!
+          load_library(:cuda_runtime)
+        end
+
+        # @param library [Symbol]
+        # @return [Fiddle::Handle, nil]
+        def handle_for(library)
+          @mutex.synchronize { @fiddle_handles[library] }
+        end
+
+        # @return [String] e.g. "13.0"
+        def cuda_version
+          ensure_cuda_runtime!
+          handle = @fiddle_handles[:cuda_runtime]
+
+          fn = Fiddle::Function.new(
+            handle['cudaRuntimeGetVersion'],
+            [Fiddle::TYPE_VOIDP],
+            Fiddle::TYPE_INT
+          )
+
+          version_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          result = fn.call(version_ptr)
+          raise CudaRuntimeError.new('Failed to get CUDA version', cuda_code: result) unless result.zero?
+
+          version = version_ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+          major = version / 1000
+          minor = (version % 1000) / 10
+
+          "#{major}.#{minor}"
+        end
+
+        # @return [void]
+        def reset!
+          @mutex.synchronize do
+            @fiddle_handles.clear
+            @loaded_libraries.clear
+            @library_paths.clear
+          end
+        end
+
+        # @return [Boolean]
+        def windows?
+          if defined?(Ignis::Platform)
+            Ignis::Platform.windows?
+          else
+            RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+          end
+        end
+
+        private
+
+        # Ensure CUDA bin path is added to Windows DLL search path.
+        # No-op on Linux (LD_LIBRARY_PATH handles it).
+        # @return [void]
+        def ensure_dll_search_path!
+          return if @dll_directory_set
+          return unless windows? && defined?(Kernel32)
+
+          cuda_bin = resolve_cuda_bin
+          return unless cuda_bin
+
+          win_path = cuda_bin.tr('/', '\\')
+          utf16_path = (win_path + "\0").encode('UTF-16LE')
+          ptr = Fiddle::Pointer.malloc(utf16_path.bytesize)
+          ptr[0, utf16_path.bytesize] = utf16_path
+
+          result = Kernel32.SetDllDirectoryW(ptr)
+          if result != 0
+            @dll_directory_set = true
+          else
+            $stderr.puts "[LibraryLoader] WARNING: Failed to set DLL directory: #{win_path}"
+          end
+        end
+
+        # @return [String, nil] CUDA binary directory
+        def resolve_cuda_bin
+          if defined?(Ignis::Platform)
+            Ignis::Platform.cuda_bin_path
+          elsif defined?(Ignis) && Ignis.respond_to?(:configuration)
+            Ignis.configuration.cuda_bin_path rescue nil
+          else
+            windows? ? 'C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v13.0/bin' : '/usr/local/cuda/lib64'
+          end
+        end
+
+        # Find a library by key and pattern.
+        # @param key [Symbol]
+        # @param pattern [String]
+        # @return [String, nil]
+        def find_library(key, pattern)
+          # Check Platform-aware search first
+          if defined?(Ignis::Platform)
+            found = Ignis::Platform.find_cuda_lib(key)
+            return found if found
+          end
+
+          # Check custom paths
+          custom = custom_paths
+          if custom[key]
+            matches = Dir.glob(File.join(custom[key], pattern))
+            return matches.max if matches.any?
+          end
+
+          # Check CUDA bin path
+          cuda_bin = resolve_cuda_bin
+          if cuda_bin
+            matches = Dir.glob(File.join(cuda_bin, pattern))
+            return matches.max if matches.any?
+          end
+
+          # Check system PATH / LD_LIBRARY_PATH
+          separator = windows? ? ';' : ':'
+          paths = ENV['PATH']&.split(separator) || []
+
+          # On Linux also check LD_LIBRARY_PATH
+          unless windows?
+            ld_paths = ENV['LD_LIBRARY_PATH']&.split(':') || []
+            paths = ld_paths + paths
+
+            # Standard Linux library locations
+            paths += ['/usr/lib/x86_64-linux-gnu', '/usr/lib64', '/usr/local/lib']
+          end
+
+          paths.each do |path|
+            matches = Dir.glob(File.join(path, pattern))
+            return matches.max if matches.any?
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end