ignis-numerics 0.0.1

data/lib/nvruby/random/curand_bindings.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module Random
+    # cuRAND library FFI bindings
+    module CuRANDBindings
+      extend FFI::Library
+
+      # Generator types (curandRngType_t)
+      CURAND_RNG_PSEUDO_DEFAULT = 100
+      CURAND_RNG_PSEUDO_XORWOW = 101
+      CURAND_RNG_PSEUDO_MRG32K3A = 121
+      CURAND_RNG_PSEUDO_MTGP32 = 141
+      CURAND_RNG_PSEUDO_MT19937 = 142
+      CURAND_RNG_PSEUDO_PHILOX4_32_10 = 161
+      CURAND_RNG_QUASI_DEFAULT = 200
+      CURAND_RNG_QUASI_SOBOL32 = 201
+      CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 202
+      CURAND_RNG_QUASI_SOBOL64 = 203
+      CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 204
+
+      # Ordering types
+      CURAND_ORDERING_PSEUDO_BEST = 100
+      CURAND_ORDERING_PSEUDO_DEFAULT = 101
+      CURAND_ORDERING_PSEUDO_SEEDED = 102
+      CURAND_ORDERING_PSEUDO_LEGACY = 103
+      CURAND_ORDERING_PSEUDO_DYNAMIC = 104
+      CURAND_ORDERING_QUASI_DEFAULT = 201
+
+      # Direction vector types
+      CURAND_DIRECTION_VECTORS_32_JOEKUO6 = 101
+      CURAND_DIRECTION_VECTORS_64_JOEKUO6 = 102
+      CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 103
+      CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104
+
+      @loaded = false
+
+      class << self
+        # Ensure cuRAND is loaded
+        # @return [void]
+        def ensure_loaded!
+          return if @loaded
+
+          CUDA::LibraryLoader.load_library(:curand)
+
+          cuda_bin = Ignis.configuration.cuda_bin_path
+          if cuda_bin
+            ffi_lib Dir.glob(File.join(cuda_bin, "curand64_*.dll")).max
+          else
+            ffi_lib "curand64_10"
+          end
+
+          attach_curand_functions!
+          @loaded = true
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def attach_curand_functions!
+          # Generator management
+          attach_function :curandCreateGenerator, [:pointer, :int], :int
+          attach_function :curandCreateGeneratorHost, [:pointer, :int], :int
+          attach_function :curandDestroyGenerator, [:pointer], :int
+          attach_function :curandSetStream, [:pointer, :pointer], :int
+          attach_function :curandSetPseudoRandomGeneratorSeed, [:pointer, :uint64], :int
+          attach_function :curandSetGeneratorOffset, [:pointer, :uint64], :int
+          attach_function :curandSetGeneratorOrdering, [:pointer, :int], :int
+          attach_function :curandSetQuasiRandomGeneratorDimensions, [:pointer, :uint], :int
+
+          # Generate random numbers
+          attach_function :curandGenerate, [:pointer, :pointer, :size_t], :int
+          attach_function :curandGenerateLongLong, [:pointer, :pointer, :size_t], :int
+
+          # Uniform distribution
+          attach_function :curandGenerateUniform, [:pointer, :pointer, :size_t], :int
+          attach_function :curandGenerateUniformDouble, [:pointer, :pointer, :size_t], :int
+
+          # Normal distribution
+          attach_function :curandGenerateNormal, [:pointer, :pointer, :size_t, :float, :float], :int
+          attach_function :curandGenerateNormalDouble, [:pointer, :pointer, :size_t, :double, :double], :int
+
+          # Log-normal distribution
+          attach_function :curandGenerateLogNormal, [:pointer, :pointer, :size_t, :float, :float], :int
+          attach_function :curandGenerateLogNormalDouble, [:pointer, :pointer, :size_t, :double, :double], :int
+
+          # Poisson distribution
+          attach_function :curandGeneratePoisson, [:pointer, :pointer, :size_t, :double], :int
+
+          # Get version
+          attach_function :curandGetVersion, [:pointer], :int
+
+          # Direction vectors for quasi-random
+          attach_function :curandGetDirectionVectors32, [:pointer, :int], :int
+          attach_function :curandGetDirectionVectors64, [:pointer, :int], :int
+          attach_function :curandGetScrambleConstants32, [:pointer], :int
+          attach_function :curandGetScrambleConstants64, [:pointer], :int
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      # Check cuRAND status and raise error if not success
+      # @param status [Integer] cuRAND status code
+      # @param context [String] Context for error message
+      # @return [void]
+      def self.check_status!(status, context = "cuRAND operation")
+        return if status.zero?
+
+        raise CuRANDError, status
+      end
+    end
+  end
+end

data/lib/nvruby/random/generator.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require "ignis"  # jit/kernels provided by the core gem
+
+module Ignis
+  module Random
+    # GPU random number generator using cuRAND
+    class Generator
+      # Available generator types
+      GENERATOR_TYPES = {
+        default: CuRANDBindings::CURAND_RNG_PSEUDO_DEFAULT,
+        xorwow: CuRANDBindings::CURAND_RNG_PSEUDO_XORWOW,
+        mrg32k3a: CuRANDBindings::CURAND_RNG_PSEUDO_MRG32K3A,
+        mtgp32: CuRANDBindings::CURAND_RNG_PSEUDO_MTGP32,
+        mt19937: CuRANDBindings::CURAND_RNG_PSEUDO_MT19937,
+        philox: CuRANDBindings::CURAND_RNG_PSEUDO_PHILOX4_32_10,
+        sobol32: CuRANDBindings::CURAND_RNG_QUASI_SOBOL32,
+        scrambled_sobol32: CuRANDBindings::CURAND_RNG_QUASI_SCRAMBLED_SOBOL32,
+        sobol64: CuRANDBindings::CURAND_RNG_QUASI_SOBOL64,
+        scrambled_sobol64: CuRANDBindings::CURAND_RNG_QUASI_SCRAMBLED_SOBOL64
+      }.freeze
+
+      # @return [Symbol] Generator type
+      attr_reader :generator_type
+
+      # @return [Integer, nil] Seed value
+      attr_reader :seed
+
+      # @return [Integer] Device index
+      attr_reader :device_index
+
+      # @param generator_type [Symbol] Type of generator
+      # @param seed [Integer, nil] Random seed
+      # @param device [Integer, nil] Device index
+      def initialize(generator_type: :xorwow, seed: nil, device: nil)
+        CuRANDBindings.ensure_loaded!
+
+        @generator_type = generator_type
+        @seed = seed
+        @device_index = device || Ignis.configuration.default_device
+        @destroyed = false
+
+        @handle = create_generator
+        set_seed(seed) if seed
+
+        ObjectSpace.define_finalizer(self, self.class.release_finalizer(@handle))
+      end
+
+      # Set the random seed
+      # @param seed [Integer] Seed value
+      # @return [self]
+      def set_seed(seed)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+        raise ArgumentError, "Cannot set seed for quasi-random generator" if quasi_random?
+
+        @seed = seed
+        status = CuRANDBindings.curandSetPseudoRandomGeneratorSeed(@handle, seed)
+        CuRANDBindings.check_status!(status, "Set generator seed")
+
+        self
+      end
+
+      # Set generator offset
+      # @param offset [Integer] Offset value
+      # @return [self]
+      def set_offset(offset)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+
+        status = CuRANDBindings.curandSetGeneratorOffset(@handle, offset)
+        CuRANDBindings.check_status!(status, "Set generator offset")
+
+        self
+      end
+
+      # Set CUDA stream
+      # @param stream [CUDA::Stream] Stream to use
+      # @return [self]
+      def set_stream(stream)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+
+        status = CuRANDBindings.curandSetStream(@handle, stream.handle)
+        CuRANDBindings.check_status!(status, "Set generator stream")
+
+        self
+      end
+
+      # Generate uniform random numbers in [0, 1)
+      # @param shape [Array<Integer>] Shape of output array
+      # @param low [Float] Lower bound (inclusive)
+      # @param high [Float] Upper bound (exclusive)
+      # @param dtype [Symbol] Data type (:float32 or :float64)
+      # @return [NvArray] Array filled with uniform random values
+      def uniform(shape, low: 0.0, high: 1.0, dtype: :float32)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+        raise UnsupportedDTypeError.new(dtype, operation: "uniform") unless %i[float32 float64].include?(dtype)
+
+        output = NvArray.new(shape: shape, dtype: dtype, device: @device_index)
+        output.to_device
+
+        count = output.size
+
+        status = if dtype == :float32
+                   CuRANDBindings.curandGenerateUniform(@handle, output.device_ffi_ptr, count)
+                 else
+                   CuRANDBindings.curandGenerateUniformDouble(@handle, output.device_ffi_ptr, count)
+                 end
+
+        CuRANDBindings.check_status!(status, "Generate uniform")
+
+        # Scale to [low, high) if needed
+        scale_uniform(output, low, high) unless low.zero? && high == 1.0
+
+        output
+      end
+
+      # Generate normal (Gaussian) random numbers
+      # @param shape [Array<Integer>] Shape of output array
+      # @param mean [Float] Mean value
+      # @param std [Float] Standard deviation
+      # @param dtype [Symbol] Data type (:float32 or :float64)
+      # @return [NvArray] Array filled with normal random values
+      def normal(shape, mean: 0.0, std: 1.0, dtype: :float32)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+        raise UnsupportedDTypeError.new(dtype, operation: "normal") unless %i[float32 float64].include?(dtype)
+
+        # cuRAND requires even number of elements for normal distribution
+        size = Array(shape).reduce(1, :*)
+        padded_size = size.even? ? size : size + 1
+
+        temp_output = CUDA::Memory.new(padded_size * DType.byte_size(dtype), device: @device_index)
+
+        status = if dtype == :float32
+                   CuRANDBindings.curandGenerateNormal(@handle, temp_output.ffi_ptr, padded_size, mean, std)
+                 else
+                   CuRANDBindings.curandGenerateNormalDouble(@handle, temp_output.ffi_ptr, padded_size, mean, std)
+                 end
+
+        CuRANDBindings.check_status!(status, "Generate normal")
+
+        # Create output array and copy
+        output = NvArray.new(shape: shape, dtype: dtype, device: @device_index)
+        output.to_device
+        output.device_memory.copy_from_device(temp_output, count: output.nbytes)
+
+        temp_output.free!
+
+        output
+      end
+
+      # Generate log-normal random numbers
+      # @param shape [Array<Integer>] Shape of output array
+      # @param mean [Float] Mean of the underlying normal distribution
+      # @param std [Float] Standard deviation of the underlying normal distribution
+      # @param dtype [Symbol] Data type (:float32 or :float64)
+      # @return [NvArray] Array filled with log-normal random values
+      def log_normal(shape, mean: 0.0, std: 1.0, dtype: :float32)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+        raise UnsupportedDTypeError.new(dtype, operation: "log_normal") unless %i[float32 float64].include?(dtype)
+
+        size = Array(shape).reduce(1, :*)
+        padded_size = size.even? ? size : size + 1
+
+        temp_output = CUDA::Memory.new(padded_size * DType.byte_size(dtype), device: @device_index)
+
+        status = if dtype == :float32
+                   CuRANDBindings.curandGenerateLogNormal(@handle, temp_output.ffi_ptr, padded_size, mean, std)
+                 else
+                   CuRANDBindings.curandGenerateLogNormalDouble(@handle, temp_output.ffi_ptr, padded_size, mean, std)
+                 end
+
+        CuRANDBindings.check_status!(status, "Generate log-normal")
+
+        output = NvArray.new(shape: shape, dtype: dtype, device: @device_index)
+        output.to_device
+        output.device_memory.copy_from_device(temp_output, count: output.nbytes)
+
+        temp_output.free!
+
+        output
+      end
+
+      # Generate Poisson-distributed random numbers
+      # @param shape [Array<Integer>] Shape of output array
+      # @param lambda_param [Float] Lambda parameter (mean and variance)
+      # @return [NvArray] Array filled with Poisson random values (uint32)
+      def poisson(shape, lambda_param:)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+        raise ArgumentError, "Lambda must be positive" unless lambda_param.positive?
+
+        output = NvArray.new(shape: shape, dtype: :uint32, device: @device_index)
+        output.to_device
+
+        status = CuRANDBindings.curandGeneratePoisson(@handle, output.device_ffi_ptr, output.size, lambda_param)
+        CuRANDBindings.check_status!(status, "Generate Poisson")
+
+        output
+      end
+
+      # Generate raw 32-bit unsigned integers
+      # @param shape [Array<Integer>] Shape of output array
+      # @return [NvArray] Array filled with random uint32 values
+      def integers(shape)
+        raise InvalidOperationError, "Generator has been destroyed" if @destroyed
+
+        output = NvArray.new(shape: shape, dtype: :uint32, device: @device_index)
+        output.to_device
+
+        status = CuRANDBindings.curandGenerate(@handle, output.device_ffi_ptr, output.size)
+        CuRANDBindings.check_status!(status, "Generate integers")
+
+        output
+      end
+
+      # Check if quasi-random generator
+      # @return [Boolean]
+      def quasi_random?
+        %i[sobol32 scrambled_sobol32 sobol64 scrambled_sobol64].include?(@generator_type)
+      end
+
+      # Check if generator has been destroyed
+      # @return [Boolean]
+      def destroyed?
+        @destroyed
+      end
+
+      # Destroy the generator and free resources
+      # @return [void]
+      def destroy!
+        return if @destroyed
+
+        CuRANDBindings.curandDestroyGenerator(@handle)
+        @handle = nil
+        @destroyed = true
+        ObjectSpace.undefine_finalizer(self)
+      end
+
+      # @return [String]
+      def to_s
+        status = @destroyed ? "destroyed" : "active"
+        "Generator(type=#{@generator_type}, seed=#{@seed || 'auto'}, #{status})"
+      end
+
+      class << self
+        # Create a finalizer for generator cleanup
+        # @param handle [FFI::Pointer] Generator handle
+        # @return [Proc]
+        def release_finalizer(handle)
+          proc do
+            CuRANDBindings.ensure_loaded!
+            CuRANDBindings.curandDestroyGenerator(handle)
+          end
+        end
+
+        # Get cuRAND version
+        # @return [Integer] Version number
+        def version
+          CuRANDBindings.ensure_loaded!
+          version_ptr = FFI::MemoryPointer.new(:int)
+          status = CuRANDBindings.curandGetVersion(version_ptr)
+          CuRANDBindings.check_status!(status, "Get cuRAND version")
+          version_ptr.read_int
+        end
+      end
+
+      private
+
+      # Create cuRAND generator
+      # @return [FFI::Pointer]
+      def create_generator
+        handle_ptr = FFI::MemoryPointer.new(:pointer)
+        rng_type = GENERATOR_TYPES[@generator_type]
+        raise ArgumentError, "Unknown generator type: #{@generator_type}" unless rng_type
+
+        status = CuRANDBindings.curandCreateGenerator(handle_ptr, rng_type)
+        CuRANDBindings.check_status!(status, "Create generator")
+
+        Ignis.logger.debug { "Created cuRAND generator: #{@generator_type}" }
+
+        handle_ptr.read_pointer
+      end
+
+      # Scale uniform output from [0,1) to [low, high) in place on the device:
+      # u' = u * (high - low) + low. (Previously a no-op that silently left values
+      # in [0,1), ignoring the requested range.)
+      def scale_uniform(output, low, high)
+        scale = (high - low).to_f
+        shift = low.to_f
+        n = output.size
+
+        unless output.dtype == :float32
+          # The affine kernel is fp32; double-precision scalar marshalling for a
+          # double kernel isn't wired yet. Fail loudly rather than return [0,1).
+          raise NotImplementedError,
+                "uniform(low:, high:) range scaling is implemented for :float32 only " \
+                "(got #{output.dtype}); default [0,1) range works for all dtypes"
+        end
+
+        kernel = Ignis::JIT::Kernels::Elementwise.affine_forward
+        ptr = output.device_ffi_ptr
+        kernel.launch(grid: [(n + 255) / 256], block: [256], args: [ptr, ptr, scale, shift, n])
+        Ignis.synchronize
+      end
+    end
+  end
+end

data/lib/nvruby/solver/amgx_bindings.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Ignis
+  module Solver
+    # FFI bindings for NVIDIA AMGX algebraic multigrid solver library
+    # AMGX provides GPU-accelerated solvers for sparse linear systems
+    module AMGXBindings
+      extend FFI::Library
+
+      # AMGX return codes
+      module RC
+        OK = 0
+        BAD_PARAMETERS = 1
+        UNKNOWN = 2
+        NOT_SUPPORTED_TARGET = 3
+        NOT_SUPPORTED_BLOCKSIZE = 4
+        CUDA_FAILURE = 5
+        THRUST_FAILURE = 6
+        NO_MEMORY = 7
+        IO_ERROR = 8
+        BAD_MODE = 9
+        CORE = 10
+        PLUGIN = 11
+        BAD_CONFIGURATION = 12
+        NOT_IMPLEMENTED = 13
+        LICENSE_NOT_FOUND = 14
+        INTERNAL = 15
+      end
+
+      # AMGX solve status
+      module SolveStatus
+        SUCCESS = 0
+        FAILED = 1
+        DIVERGED = 2
+        NOT_CONVERGED = 3
+      end
+
+      # AMGX modes (memory space + precision)
+      # Format: mode_<memory><vec><mat><idx>
+      # h=host, d=device, D=double, F=float, I=int
+      module Mode
+        HOST_DDI = 8192   # Host, double vec, double mat, int idx
+        HOST_DFI = 8448   # Host, double vec, float mat, int idx
+        HOST_FFI = 8464   # Host, float vec, float mat, int idx
+        DEVICE_DDI = 8193 # Device, double vec, double mat, int idx
+        DEVICE_DFI = 8449 # Device, double vec, float mat, int idx
+        DEVICE_FFI = 8465 # Device, float vec, float mat, int idx
+      end
+
+      class << self
+        # @return [Boolean]
+        def loaded?
+          @loaded ||= false
+        end
+
+        # Load AMGX library
+        # @param dll_path [String, nil] Path to amgxsh.dll (searches common paths if nil)
+        # @return [void]
+        def ensure_loaded!(dll_path = nil)
+          return if @loaded
+
+          paths = dll_path ? [dll_path] : search_paths
+          loaded_path = nil
+
+          paths.each do |path|
+            next unless File.exist?(path)
+
+            begin
+              ffi_lib path
+              loaded_path = path
+              break
+            rescue FFI::LoadError
+              next
+            end
+          end
+
+          raise LoadError, "Could not load amgxsh.dll. Searched: #{paths.join(', ')}" unless loaded_path
+
+          attach_functions!
+          @loaded = true
+          Ignis.logger.info { "Loaded AMGX: #{loaded_path}" }
+        end
+
+        private
+
+        def search_paths
+          [
+            "C:/AMGX/build/Release/amgxsh.dll",
+            "C:/AMGX/build/Debug/amgxsh.dll",
+            "C:/Program Files/AMGX/bin/amgxsh.dll",
+            File.join(Ignis.configuration.cuda_bin_path || "", "amgxsh.dll")
+          ].compact
+        end
+
+        def attach_functions!
+          # Initialize/Finalize
+          attach_function :AMGX_initialize, [], :int
+          attach_function :AMGX_finalize, [], :int
+          attach_function :AMGX_get_api_version, [:pointer, :pointer], :int
+          attach_function :AMGX_get_error_string, [:int, :pointer, :int], :int
+
+          # Config
+          attach_function :AMGX_config_create, [:pointer, :string], :int
+          attach_function :AMGX_config_create_from_file, [:pointer, :string], :int
+          attach_function :AMGX_config_destroy, [:pointer], :int
+
+          # Resources
+          attach_function :AMGX_resources_create_simple, [:pointer, :pointer], :int
+          attach_function :AMGX_resources_destroy, [:pointer], :int
+
+          # Matrix
+          attach_function :AMGX_matrix_create, [:pointer, :pointer, :int], :int
+          attach_function :AMGX_matrix_destroy, [:pointer], :int
+          attach_function :AMGX_matrix_upload_all, [
+            :pointer,  # mtx handle
+            :int,      # n
+            :int,      # nnz
+            :int,      # block_dimx
+            :int,      # block_dimy
+            :pointer,  # row_ptrs
+            :pointer,  # col_indices
+            :pointer,  # data
+            :pointer   # diag_data (can be NULL)
+          ], :int
+          attach_function :AMGX_matrix_get_size, [:pointer, :pointer, :pointer, :pointer], :int
+
+          # Vector
+          attach_function :AMGX_vector_create, [:pointer, :pointer, :int], :int
+          attach_function :AMGX_vector_destroy, [:pointer], :int
+          attach_function :AMGX_vector_upload, [:pointer, :int, :int, :pointer], :int
+          attach_function :AMGX_vector_download, [:pointer, :pointer], :int
+          attach_function :AMGX_vector_set_zero, [:pointer, :int, :int], :int
+
+          # Solver
+          attach_function :AMGX_solver_create, [:pointer, :pointer, :int, :pointer], :int
+          attach_function :AMGX_solver_destroy, [:pointer], :int
+          attach_function :AMGX_solver_setup, [:pointer, :pointer], :int
+          attach_function :AMGX_solver_solve, [:pointer, :pointer, :pointer], :int
+          attach_function :AMGX_solver_solve_with_0_initial_guess, [:pointer, :pointer, :pointer], :int
+          attach_function :AMGX_solver_get_status, [:pointer, :pointer], :int
+          attach_function :AMGX_solver_get_iterations_number, [:pointer, :pointer], :int
+          attach_function :AMGX_solver_get_iteration_residual, [:pointer, :int, :int, :pointer], :int
+        end
+      end
+
+      # Check AMGX return code and raise error if not OK
+      # @param rc [Integer] Return code
+      # @param context [String] Error context
+      # @return [void]
+      def self.check_rc!(rc, context = "AMGX operation")
+        return if rc == RC::OK
+
+        msg_buf = FFI::MemoryPointer.new(:char, 4096)
+        AMGX_get_error_string(rc, msg_buf, 4096)
+        error_msg = msg_buf.read_string
+
+        raise AMGXError.new("#{context}: #{error_msg}", amgx_code: rc)
+      end
+    end
+
+    # AMGX-specific error class
+    class AMGXError < Ignis::Error
+      # @return [Integer] AMGX return code
+      attr_reader :amgx_code
+
+      def initialize(message, amgx_code: nil)
+        super(message)
+        @amgx_code = amgx_code
+      end
+    end
+  end
+end