ignis-numerics 0.0.1

data/lib/nvruby/solver/amgx_config.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ignis
+  module Solver
+    # Configuration builder for AMGX solver
+    # Provides preset configurations and custom config strings
+    class AMGXConfig
+      # Predefined solver configurations
+      PRESETS = {
+        # Classical AMG with V-cycle, Jacobi smoother
+        classical_v_cycle: <<~CONFIG,
+          config_version=2,
+          solver(main)=AMG,
+          main:algorithm=CLASSICAL,
+          main:selector=PMIS,
+          main:interpolator=D2,
+          main:presweeps=2,
+          main:postsweeps=2,
+          main:max_iters=100,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-8,
+          main:norm=L2,
+          main:cycle=V,
+          main:smoother=BLOCK_JACOBI,
+          main:coarse_solver=DENSE_LU_SOLVER,
+          main:max_levels=20
+        CONFIG
+
+        # Aggregation AMG with V-cycle
+        aggregation_v_cycle: <<~CONFIG,
+          config_version=2,
+          solver(main)=AMG,
+          main:algorithm=AGGREGATION,
+          main:selector=SIZE_2,
+          main:presweeps=2,
+          main:postsweeps=2,
+          main:max_iters=100,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-8,
+          main:norm=L2,
+          main:cycle=V,
+          main:smoother=MULTICOLOR_GS,
+          main:coarse_solver=DENSE_LU_SOLVER
+        CONFIG
+
+        # PCG with AMG preconditioner
+        pcg_amg: <<~CONFIG,
+          config_version=2,
+          solver(main)=PCG,
+          main:preconditioner(amg)=AMG,
+          main:max_iters=1000,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-10,
+          main:norm=L2,
+          amg:algorithm=CLASSICAL,
+          amg:max_iters=1,
+          amg:cycle=V,
+          amg:smoother=BLOCK_JACOBI
+        CONFIG
+
+        # PBICGSTAB with AMG preconditioner
+        pbicgstab_amg: <<~CONFIG,
+          config_version=2,
+          solver(main)=PBICGSTAB,
+          main:preconditioner(amg)=AMG,
+          main:max_iters=1000,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-10,
+          main:norm=L2,
+          amg:algorithm=AGGREGATION,
+          amg:max_iters=1,
+          amg:cycle=V
+        CONFIG
+
+        # Simple Jacobi iteration
+        jacobi: <<~CONFIG,
+          config_version=2,
+          solver(main)=BLOCK_JACOBI,
+          main:max_iters=1000,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-8
+        CONFIG
+
+        # Gauss-Seidel
+        gauss_seidel: <<~CONFIG
+          config_version=2,
+          solver(main)=MULTICOLOR_GS,
+          main:max_iters=1000,
+          main:convergence=RELATIVE_INI_CORE,
+          main:tolerance=1e-8
+        CONFIG
+      }.freeze
+
+      # @return [String] Configuration string
+      attr_reader :config_string
+
+      # Create configuration from preset or custom string
+      # @param preset [Symbol, nil] Preset name (:classical_v_cycle, :aggregation_v_cycle, etc.)
+      # @param custom [String, nil] Custom configuration string
+      # @param options [Hash] Override options
+      def initialize(preset: nil, custom: nil, **options)
+        if custom
+          @config_string = custom
+        elsif preset
+          raise ArgumentError, "Unknown preset: #{preset}" unless PRESETS.key?(preset)
+
+          @config_string = PRESETS[preset].gsub(/\s+/, "")
+        else
+          @config_string = PRESETS[:classical_v_cycle].gsub(/\s+/, "")
+        end
+
+        apply_options!(options) unless options.empty?
+      end
+
+      # @return [String]
+      def to_s
+        @config_string
+      end
+
+      # List available presets
+      # @return [Array<Symbol>]
+      def self.presets
+        PRESETS.keys
+      end
+
+      private
+
+      def apply_options!(options)
+        options.each do |key, value|
+          pattern = /#{key}=[^,]+/
+          replacement = "#{key}=#{value}"
+
+          if @config_string.match?(pattern)
+            @config_string = @config_string.gsub(pattern, replacement)
+          else
+            @config_string += ",main:#{key}=#{value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/solver/amgx_solver.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative 'amgx_bindings'
+require_relative 'amgx_config'
+
+module Ignis
+  module Solver
+    # GPU-accelerated algebraic multigrid solver using NVIDIA AMGX
+    # Solves sparse linear systems Ax = b
+    class AMGXSolver
+      # @return [AMGXConfig] Solver configuration
+      attr_reader :config
+
+      # @return [Symbol] Precision mode (:double or :float)
+      attr_reader :precision
+
+      # @return [Integer] Number of iterations from last solve
+      attr_reader :iterations
+
+      # @return [Float] Final residual from last solve
+      attr_reader :residual
+
+      # @param config [Symbol, String, AMGXConfig] Configuration (preset symbol, string, or AMGXConfig)
+      # @param precision [Symbol] :double or :float
+      # @param device [Boolean] Use GPU (true) or CPU (false)
+      def initialize(config: :classical_v_cycle, precision: :double, device: true)
+        AMGXBindings.ensure_loaded!
+
+        @config = case config
+                  when Symbol
+                    AMGXConfig.new(preset: config)
+                  when String
+                    AMGXConfig.new(custom: config)
+                  when AMGXConfig
+                    config
+                  else
+                    raise ArgumentError, "Invalid config type: #{config.class}"
+                  end
+
+        @precision = precision
+        @device = device
+        @mode = determine_mode
+        @initialized = false
+        @iterations = 0
+        @residual = 0.0
+
+        initialize_amgx!
+      end
+
+      # Solve sparse linear system Ax = b
+      # @param a [Hash] Sparse matrix in CSR format { row_ptr:, col_idx:, values:, n:, nnz: }
+      # @param b [Array<Float>, NvArray] Right-hand side vector
+      # @param x0 [Array<Float>, NvArray, nil] Initial guess (nil for zero)
+      # @return [Array<Float>] Solution vector
+      def solve(a, b, x0: nil)
+        raise AMGXError, "Solver not initialized" unless @initialized
+
+        n = a[:n]
+        nnz = a[:nnz]
+
+        upload_matrix(a)
+        upload_vector(@rhs_handle, b)
+
+        if x0
+          upload_vector(@sol_handle, x0)
+          rc = AMGXBindings.AMGX_solver_solve(@solver_handle, @rhs_handle, @sol_handle)
+        else
+          rc = AMGXBindings.AMGX_solver_solve_with_0_initial_guess(
+            @solver_handle, @rhs_handle, @sol_handle
+          )
+        end
+        AMGXBindings.check_rc!(rc, "AMGX_solver_solve")
+
+        update_solve_stats!
+        download_solution(n)
+      end
+
+      # Get solve status
+      # @return [Symbol] :success, :failed, :diverged, or :not_converged
+      def status
+        status_ptr = FFI::MemoryPointer.new(:int)
+        AMGXBindings.AMGX_solver_get_status(@solver_handle, status_ptr)
+
+        case status_ptr.read_int
+        when AMGXBindings::SolveStatus::SUCCESS then :success
+        when AMGXBindings::SolveStatus::FAILED then :failed
+        when AMGXBindings::SolveStatus::DIVERGED then :diverged
+        when AMGXBindings::SolveStatus::NOT_CONVERGED then :not_converged
+        else :unknown
+        end
+      end
+
+      # Release all AMGX resources
+      # @return [void]
+      def destroy!
+        return unless @initialized
+
+        AMGXBindings.AMGX_solver_destroy(@solver_handle) if @solver_handle
+        AMGXBindings.AMGX_vector_destroy(@sol_handle) if @sol_handle
+        AMGXBindings.AMGX_vector_destroy(@rhs_handle) if @rhs_handle
+        AMGXBindings.AMGX_matrix_destroy(@matrix_handle) if @matrix_handle
+        AMGXBindings.AMGX_resources_destroy(@resources_handle) if @resources_handle
+        AMGXBindings.AMGX_config_destroy(@config_handle) if @config_handle
+        AMGXBindings.AMGX_finalize
+
+        @initialized = false
+      end
+
+      private
+
+      def determine_mode
+        if @device
+          @precision == :double ? AMGXBindings::Mode::DEVICE_DDI : AMGXBindings::Mode::DEVICE_FFI
+        else
+          @precision == :double ? AMGXBindings::Mode::HOST_DDI : AMGXBindings::Mode::HOST_FFI
+        end
+      end
+
+      def initialize_amgx!
+        rc = AMGXBindings.AMGX_initialize
+        AMGXBindings.check_rc!(rc, "AMGX_initialize")
+
+        @config_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_config_create(@config_handle, @config.to_s)
+        AMGXBindings.check_rc!(rc, "AMGX_config_create")
+        @config_handle = @config_handle.read_pointer
+
+        @resources_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_resources_create_simple(@resources_handle, @config_handle)
+        AMGXBindings.check_rc!(rc, "AMGX_resources_create_simple")
+        @resources_handle = @resources_handle.read_pointer
+
+        @matrix_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_matrix_create(@matrix_handle, @resources_handle, @mode)
+        AMGXBindings.check_rc!(rc, "AMGX_matrix_create")
+        @matrix_handle = @matrix_handle.read_pointer
+
+        @rhs_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_vector_create(@rhs_handle, @resources_handle, @mode)
+        AMGXBindings.check_rc!(rc, "AMGX_vector_create (rhs)")
+        @rhs_handle = @rhs_handle.read_pointer
+
+        @sol_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_vector_create(@sol_handle, @resources_handle, @mode)
+        AMGXBindings.check_rc!(rc, "AMGX_vector_create (sol)")
+        @sol_handle = @sol_handle.read_pointer
+
+        @solver_handle = FFI::MemoryPointer.new(:pointer)
+        rc = AMGXBindings.AMGX_solver_create(@solver_handle, @resources_handle, @mode, @config_handle)
+        AMGXBindings.check_rc!(rc, "AMGX_solver_create")
+        @solver_handle = @solver_handle.read_pointer
+
+        @initialized = true
+        @matrix_uploaded = false
+
+        ObjectSpace.define_finalizer(self, self.class.release_finalizer(
+          @solver_handle, @sol_handle, @rhs_handle, @matrix_handle,
+          @resources_handle, @config_handle
+        ))
+      end
+
+      def upload_matrix(a)
+        n = a[:n]
+        nnz = a[:nnz]
+        row_ptr = a[:row_ptr]
+        col_idx = a[:col_idx]
+        values = a[:values]
+
+        row_ptr_buf = FFI::MemoryPointer.new(:int, row_ptr.length)
+        row_ptr_buf.write_array_of_int(row_ptr)
+
+        col_idx_buf = FFI::MemoryPointer.new(:int, col_idx.length)
+        col_idx_buf.write_array_of_int(col_idx)
+
+        if @precision == :double
+          values_buf = FFI::MemoryPointer.new(:double, values.length)
+          values_buf.write_array_of_double(values)
+        else
+          values_buf = FFI::MemoryPointer.new(:float, values.length)
+          values_buf.write_array_of_float(values)
+        end
+
+        rc = AMGXBindings.AMGX_matrix_upload_all(
+          @matrix_handle, n, nnz, 1, 1,
+          row_ptr_buf, col_idx_buf, values_buf, FFI::Pointer::NULL
+        )
+        AMGXBindings.check_rc!(rc, "AMGX_matrix_upload_all")
+
+        unless @matrix_uploaded
+          rc = AMGXBindings.AMGX_solver_setup(@solver_handle, @matrix_handle)
+          AMGXBindings.check_rc!(rc, "AMGX_solver_setup")
+          @matrix_uploaded = true
+        end
+      end
+
+      def upload_vector(handle, data)
+        data = data.to_a if data.respond_to?(:to_a)
+        n = data.length
+
+        if @precision == :double
+          buf = FFI::MemoryPointer.new(:double, n)
+          buf.write_array_of_double(data)
+        else
+          buf = FFI::MemoryPointer.new(:float, n)
+          buf.write_array_of_float(data)
+        end
+
+        rc = AMGXBindings.AMGX_vector_upload(handle, n, 1, buf)
+        AMGXBindings.check_rc!(rc, "AMGX_vector_upload")
+      end
+
+      def download_solution(n)
+        if @precision == :double
+          buf = FFI::MemoryPointer.new(:double, n)
+          rc = AMGXBindings.AMGX_vector_download(@sol_handle, buf)
+          AMGXBindings.check_rc!(rc, "AMGX_vector_download")
+          buf.read_array_of_double(n)
+        else
+          buf = FFI::MemoryPointer.new(:float, n)
+          rc = AMGXBindings.AMGX_vector_download(@sol_handle, buf)
+          AMGXBindings.check_rc!(rc, "AMGX_vector_download")
+          buf.read_array_of_float(n)
+        end
+      end
+
+      def update_solve_stats!
+        iter_ptr = FFI::MemoryPointer.new(:int)
+        AMGXBindings.AMGX_solver_get_iterations_number(@solver_handle, iter_ptr)
+        @iterations = iter_ptr.read_int
+
+        res_ptr = FFI::MemoryPointer.new(:double)
+        AMGXBindings.AMGX_solver_get_iteration_residual(@solver_handle, @iterations - 1, 0, res_ptr)
+        @residual = res_ptr.read_double
+      end
+
+      class << self
+        def release_finalizer(solver, sol, rhs, matrix, resources, config)
+          proc do
+            AMGXBindings.AMGX_solver_destroy(solver) if solver && !solver.null?
+            AMGXBindings.AMGX_vector_destroy(sol) if sol && !sol.null?
+            AMGXBindings.AMGX_vector_destroy(rhs) if rhs && !rhs.null?
+            AMGXBindings.AMGX_matrix_destroy(matrix) if matrix && !matrix.null?
+            AMGXBindings.AMGX_resources_destroy(resources) if resources && !resources.null?
+            AMGXBindings.AMGX_config_destroy(config) if config && !config.null?
+            AMGXBindings.AMGX_finalize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/solver/cudss_bindings.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module Solver
+    # FFI bindings for NVIDIA cuDSS v0.7+
+    # High-performance direct sparse solvers for CUDA
+    module CuDSSBindings
+      extend FFI::Library
+
+      # cuDSS status codes
+      CUDSS_STATUS_SUCCESS = 0
+      CUDSS_STATUS_NOT_INITIALIZED = 1
+      CUDSS_STATUS_ALLOC_FAILED = 2
+      CUDSS_STATUS_INVALID_VALUE = 3
+      CUDSS_STATUS_ARCH_MISMATCH = 4
+      CUDSS_STATUS_MAPPING_ERROR = 5
+      CUDSS_STATUS_EXECUTION_FAILED = 6
+      CUDSS_STATUS_INTERNAL_ERROR = 7
+      CUDSS_STATUS_NOT_SUPPORTED = 8
+
+      # cuDSS Phases (from cudss.h - these are bitmask values)
+      CUDSS_PHASE_REORDERING = 1             # 1 << 0
+      CUDSS_PHASE_SYMBOLIC_FACTORIZATION = 2 # 1 << 1
+      CUDSS_PHASE_ANALYSIS = 3               # REORDERING | SYMBOLIC_FACTORIZATION = 1 | 2 = 3
+      CUDSS_PHASE_FACTORIZATION = 4          # 1 << 2
+      CUDSS_PHASE_REFACTORIZATION = 8        # 1 << 3
+      CUDSS_PHASE_SOLVE_FWD_PERM = 16        # 1 << 4
+      CUDSS_PHASE_SOLVE_FWD = 32             # 1 << 5
+      CUDSS_PHASE_SOLVE_DIAG = 64            # 1 << 6
+      CUDSS_PHASE_SOLVE_BWD = 128            # 1 << 7
+      CUDSS_PHASE_SOLVE_BWD_PERM = 256       # 1 << 8
+      CUDSS_PHASE_SOLVE_REFINEMENT = 512     # 1 << 9
+      CUDSS_PHASE_SOLVE = 1008               # All solve phases combined (16|32|64|128|256|512)
+
+      @loaded = false
+      @mutex = Mutex.new
+
+      class << self
+        # Ensure cuDSS library is loaded and functions attached
+        # @return [void]
+        def ensure_loaded!
+          @mutex.synchronize do
+            return if @loaded
+
+            CUDA::LibraryLoader.load_library(:cudss)
+            dll_path = CUDA::LibraryLoader.library_paths[:cudss]
+            
+            raise LibraryNotFoundError, "cudss" unless dll_path
+
+            ffi_lib dll_path
+            attach_functions!
+
+            @loaded = true
+            Ignis.logger.debug("cuDSS bindings loaded from #{dll_path}")
+          end
+        end
+
+        # Check status and raise error if not success
+        # @param status [Integer] status code
+        # @param context [String] Context for error message
+        # @raise [CuDSSError] If status is not success
+        def check_status!(status, context = "cuDSS operation")
+          return if status == CUDSS_STATUS_SUCCESS
+
+          raise CuDSSError.new("#{context} failed", status_code: status)
+        end
+
+        private
+
+        def attach_functions!
+          # Handle management
+          attach_function :cudssCreate, [:pointer], :int
+          attach_function :cudssDestroy, [:pointer], :int
+
+          # Stream management
+          attach_function :cudssSetStream, [:pointer, :pointer], :int
+
+          # Config and Data management
+          attach_function :cudssConfigSet, [:pointer, :int, :pointer, :size_t], :int
+          attach_function :cudssConfigGet, [:pointer, :int, :pointer, :size_t], :int
+          
+          # Matrix and Data Object creation (these are usually wrappers for raw pointers)
+          # cudssMatrixCreateDn: matrixPtr, nRows, nCols, ld, values, valueType, order
+          attach_function :cudssMatrixCreateDn, [:pointer, :int64, :int64, :int64, :pointer, :int, :int], :int
+          # cudssMatrixCreateCsr: matrixPtr, nRows, nCols, nnz, rowStart, rowEnd, colIndices, values, indexType, valueType, mType, mView, indexBase
+          attach_function :cudssMatrixCreateCsr, [:pointer, :int64, :int64, :int64, :pointer, :pointer, :pointer, :pointer, :int, :int, :int, :int, :int], :int
+          attach_function :cudssMatrixDestroy, [:pointer], :int
+
+          # Config object: cudssConfigCreate(config) -> 1 output pointer
+          attach_function :cudssConfigCreate, [:pointer], :int
+          attach_function :cudssConfigDestroy, [:pointer], :int
+          
+          # Data object: cudssDataCreate(handle, data) -> handle in, data out
+          attach_function :cudssDataCreate, [:pointer, :pointer], :int
+          attach_function :cudssDataDestroy, [:pointer, :pointer], :int
+
+          # Execution
+          attach_function :cudssExecute, [:pointer, :int, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+        end
+      end
+    end
+
+    # Specialized error for cuDSS
+    class CuDSSError < StandardError
+      attr_reader :status_code
+
+      def initialize(message, status_code: nil)
+        @status_code = status_code
+        super("#{message} (Status: #{status_code})")
+      end
+    end
+  end
+end