ignis 0.0.1

data/lib/nvruby/linalg/cublas_bindings.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module LinAlg
+    # cuBLAS library FFI bindings
+    module CuBLASBindings
+      extend FFI::Library
+
+      # cuBLAS operation types
+      CUBLAS_OP_N = 0  # No transpose
+      CUBLAS_OP_T = 1  # Transpose
+      CUBLAS_OP_C = 2  # Conjugate transpose
+
+      # cuBLAS fill modes
+      CUBLAS_FILL_MODE_LOWER = 0
+      CUBLAS_FILL_MODE_UPPER = 1
+      CUBLAS_FILL_MODE_FULL = 2
+
+      # cuBLAS diagonal types
+      CUBLAS_DIAG_NON_UNIT = 0
+      CUBLAS_DIAG_UNIT = 1
+
+      # cuBLAS side modes
+      CUBLAS_SIDE_LEFT = 0
+      CUBLAS_SIDE_RIGHT = 1
+
+      # cuBLAS pointer modes
+      CUBLAS_POINTER_MODE_HOST = 0
+      CUBLAS_POINTER_MODE_DEVICE = 1
+
+      # cuBLAS atomics modes
+      CUBLAS_ATOMICS_NOT_ALLOWED = 0
+      CUBLAS_ATOMICS_ALLOWED = 1
+
+      # cuBLAS compute types
+      CUBLAS_COMPUTE_16F = 64
+      CUBLAS_COMPUTE_16F_PEDANTIC = 65
+      CUBLAS_COMPUTE_32F = 68
+      CUBLAS_COMPUTE_32F_PEDANTIC = 69
+      CUBLAS_COMPUTE_32F_FAST_16F = 74
+      CUBLAS_COMPUTE_32F_FAST_16BF = 75
+      CUBLAS_COMPUTE_32F_FAST_TF32 = 77
+      CUBLAS_COMPUTE_64F = 70
+      CUBLAS_COMPUTE_64F_PEDANTIC = 71
+      CUBLAS_COMPUTE_32I = 72
+      CUBLAS_COMPUTE_32I_PEDANTIC = 73
+
+      # cuBLASLt epilogue types
+      CUBLASLT_EPILOGUE_DEFAULT = 1
+      CUBLASLT_EPILOGUE_RELU = 2
+      CUBLASLT_EPILOGUE_RELU_AUX = 258
+      CUBLASLT_EPILOGUE_BIAS = 4
+      CUBLASLT_EPILOGUE_RELU_BIAS = 6
+      CUBLASLT_EPILOGUE_RELU_AUX_BIAS = 262
+      CUBLASLT_EPILOGUE_DRELU = 520
+      CUBLASLT_EPILOGUE_DRELU_BGRAD = 536
+      CUBLASLT_EPILOGUE_GELU = 32
+      CUBLASLT_EPILOGUE_GELU_AUX = 288
+      CUBLASLT_EPILOGUE_GELU_BIAS = 36
+      CUBLASLT_EPILOGUE_GELU_AUX_BIAS = 292
+      CUBLASLT_EPILOGUE_DGELU = 544
+      CUBLASLT_EPILOGUE_DGELU_BGRAD = 560
+      CUBLASLT_EPILOGUE_BGRADA = 576
+      CUBLASLT_EPILOGUE_BGRADB = 592
+
+      # cuBLAS Math Modes for Tensor Core control
+      CUBLAS_DEFAULT_MATH = 0
+      CUBLAS_TENSOR_OP_MATH = 1
+      CUBLAS_PEDANTIC_MATH = 2
+      CUBLAS_TF32_TENSOR_OP_MATH = 3
+      CUBLAS_MATH_DISALLOW_REDUCED_PRECISION_REDUCTION = 16
+
+      @loaded = false
+      @handle = nil
+      @lt_handle = nil
+
+      class << self
+        # @return [FFI::Pointer, nil] cuBLAS handle
+        attr_accessor :handle
+
+        # @return [FFI::Pointer, nil] cuBLASLt handle
+        attr_accessor :lt_handle
+
+        # Ensure cuBLAS is loaded
+        # @return [void]
+        def ensure_loaded!
+          return if @loaded
+
+          CUDA::LibraryLoader.load_library(:cublas)
+
+          cuda_bin = Ignis.configuration.cuda_bin_path
+          if cuda_bin
+            ffi_lib Dir.glob(File.join(cuda_bin, "cublas64_*.dll")).max
+          else
+            ffi_lib "cublas64_12"
+          end
+
+          attach_cublas_functions!
+          initialize_cublas!
+
+          @loaded = true
+        end
+
+        # Get or create cuBLAS handle
+        # @return [FFI::Pointer]
+        def get_handle
+          ensure_loaded!
+          @handle
+        end
+
+        # Finalize cuBLAS
+        # @return [void]
+        def finalize!
+          return unless @handle
+
+          cublasDestroy_v2(@handle)
+          @handle = nil
+          @loaded = false
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def attach_cublas_functions!
+          # Handle management
+          attach_function :cublasCreate_v2, [:pointer], :int
+          attach_function :cublasDestroy_v2, [:pointer], :int
+          attach_function :cublasSetStream_v2, [:pointer, :pointer], :int
+          attach_function :cublasGetStream_v2, [:pointer, :pointer], :int
+          attach_function :cublasSetPointerMode_v2, [:pointer, :int], :int
+          attach_function :cublasGetPointerMode_v2, [:pointer, :pointer], :int
+          attach_function :cublasSetMathMode, [:pointer, :int], :int
+          attach_function :cublasGetMathMode, [:pointer, :pointer], :int
+
+          # Level 1 BLAS - Vector operations
+          attach_function :cublasSscal_v2, [:pointer, :int, :pointer, :pointer, :int], :int
+          attach_function :cublasDscal_v2, [:pointer, :int, :pointer, :pointer, :int], :int
+          attach_function :cublasSaxpy_v2, [:pointer, :int, :pointer, :pointer, :int, :pointer, :int], :int
+          attach_function :cublasDaxpy_v2, [:pointer, :int, :pointer, :pointer, :int, :pointer, :int], :int
+          attach_function :cublasSdot_v2, [:pointer, :int, :pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasDdot_v2, [:pointer, :int, :pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasSnrm2_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasDnrm2_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasSasum_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasDasum_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasIsamax_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasIdamax_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasIsamin_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasIdamin_v2, [:pointer, :int, :pointer, :int, :pointer], :int
+          attach_function :cublasScopy_v2, [:pointer, :int, :pointer, :int, :pointer, :int], :int
+          attach_function :cublasDcopy_v2, [:pointer, :int, :pointer, :int, :pointer, :int], :int
+          attach_function :cublasSswap_v2, [:pointer, :int, :pointer, :int, :pointer, :int], :int
+          attach_function :cublasDswap_v2, [:pointer, :int, :pointer, :int, :pointer, :int], :int
+
+          # Level 2 BLAS - Matrix-Vector operations
+          attach_function :cublasSgemv_v2, [
+            :pointer, :int, :int, :int,
+            :pointer, :pointer, :int, :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+          attach_function :cublasDgemv_v2, [
+            :pointer, :int, :int, :int,
+            :pointer, :pointer, :int, :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+
+          # Level 3 BLAS - Matrix-Matrix operations
+          attach_function :cublasSgemm_v2, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int,
+            :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+          attach_function :cublasDgemm_v2, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int,
+            :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+          attach_function :cublasCgemm_v2, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int,
+            :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+          attach_function :cublasZgemm_v2, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int,
+            :pointer, :int,
+            :pointer, :pointer, :int
+          ], :int
+
+          # Strided batched GEMM
+          attach_function :cublasSgemmStridedBatched, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int, :long_long,
+            :pointer, :int, :long_long,
+            :pointer, :pointer, :int, :long_long,
+            :int
+          ], :int
+          attach_function :cublasDgemmStridedBatched, [
+            :pointer, :int, :int,
+            :int, :int, :int,
+            :pointer, :pointer, :int, :long_long,
+            :pointer, :int, :long_long,
+            :pointer, :pointer, :int, :long_long,
+            :int
+          ], :int
+
+          # TRSM - Triangular solve
+          attach_function :cublasStrsm_v2, [
+            :pointer, :int, :int, :int, :int,
+            :int, :int, :pointer, :pointer, :int, :pointer, :int
+          ], :int
+          attach_function :cublasDtrsm_v2, [
+            :pointer, :int, :int, :int, :int,
+            :int, :int, :pointer, :pointer, :int, :pointer, :int
+          ], :int
+
+          # SYRK - Symmetric rank-k update
+          attach_function :cublasSsyrk_v2, [
+            :pointer, :int, :int, :int, :int,
+            :pointer, :pointer, :int, :pointer, :pointer, :int
+          ], :int
+          attach_function :cublasDsyrk_v2, [
+            :pointer, :int, :int, :int, :int,
+            :pointer, :pointer, :int, :pointer, :pointer, :int
+          ], :int
+
+          # cublasGemmEx - Mixed precision GEMM with Tensor Core support
+          # Signature: cublasGemmEx(handle, transa, transb, m, n, k,
+          #                         alpha, A, Atype, lda, B, Btype, ldb,
+          #                         beta, C, Ctype, ldc, computeType, algo)
+          attach_function :cublasGemmEx, [
+            :pointer,   # handle
+            :int,       # transa
+            :int,       # transb
+            :int,       # m
+            :int,       # n
+            :int,       # k
+            :pointer,   # alpha
+            :pointer,   # A
+            :int,       # Atype (cudaDataType_t)
+            :int,       # lda
+            :pointer,   # B
+            :int,       # Btype (cudaDataType_t)
+            :int,       # ldb
+            :pointer,   # beta
+            :pointer,   # C
+            :int,       # Ctype (cudaDataType_t)
+            :int,       # ldc
+            :int,       # computeType (cublasComputeType_t)
+            :int        # algo (cublasGemmAlgo_t)
+          ], :int
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Initialize cuBLAS handle
+        def initialize_cublas!
+          handle_ptr = FFI::MemoryPointer.new(:pointer)
+          status = cublasCreate_v2(handle_ptr)
+
+          raise CuBLASError, status unless status.zero?
+
+          @handle = handle_ptr.read_pointer
+
+          # Enable Tensor Core math mode for maximum FP16/TF32 performance
+          math_status = cublasSetMathMode(@handle, CUBLAS_TENSOR_OP_MATH)
+          if math_status.zero?
+            Ignis.logger.info("cuBLAS initialized successfully with Tensor Core math enabled")
+          else
+            Ignis.logger.info("cuBLAS initialized successfully (Tensor Core math mode unavailable)")
+          end
+        end
+      end
+
+      # Check cuBLAS status and raise error if not success
+      # @param status [Integer] cuBLAS status code
+      # @param context [String] Context for error message
+      # @return [void]
+      def self.check_status!(status, context = "cuBLAS operation")
+        return if status.zero?
+
+        raise CuBLASError, status
+      end
+    end
+  end
+end

data/lib/nvruby/linalg/cublaslt_bindings.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module LinAlg
+    # cuBLASLt (Light) library FFI bindings for advanced GEMM optimization
+    #
+    # cuBLASLt provides:
+    # - Descriptor-based matrix multiplication
+    # - Heuristic algorithm selection
+    # - Workspace optimization
+    # - Custom epilog operations (bias, activation fusion)
+    module CuBLASLtBindings
+      extend FFI::Library
+
+      # ==========================================================================
+      # cuBLASLt Constants
+      # ==========================================================================
+
+      # Matrix layout order
+      CUBLASLT_ORDER_COL = 0
+      CUBLASLT_ORDER_ROW = 1
+      CUBLASLT_ORDER_COL32 = 2
+      CUBLASLT_ORDER_COL4_4R2_8C = 3
+      CUBLASLT_ORDER_COL32_2R_4R4 = 4
+
+      # Matmul descriptor attributes
+      CUBLASLT_MATMUL_DESC_COMPUTE_TYPE = 0
+      CUBLASLT_MATMUL_DESC_SCALE_TYPE = 1
+      CUBLASLT_MATMUL_DESC_POINTER_MODE = 2
+      CUBLASLT_MATMUL_DESC_TRANSA = 3
+      CUBLASLT_MATMUL_DESC_TRANSB = 4
+      CUBLASLT_MATMUL_DESC_TRANSC = 5
+      CUBLASLT_MATMUL_DESC_EPILOGUE = 6
+      CUBLASLT_MATMUL_DESC_BIAS_POINTER = 7
+      CUBLASLT_MATMUL_DESC_BIAS_DATA_TYPE = 8
+      CUBLASLT_MATMUL_DESC_A_SCALE_POINTER = 9
+      CUBLASLT_MATMUL_DESC_B_SCALE_POINTER = 10
+      CUBLASLT_MATMUL_DESC_C_SCALE_POINTER = 11
+      CUBLASLT_MATMUL_DESC_D_SCALE_POINTER = 12
+      CUBLASLT_MATMUL_DESC_AMAX_D_POINTER = 13
+      CUBLASLT_MATMUL_DESC_SM_COUNT_TARGET = 14
+      CUBLASLT_MATMUL_DESC_FAST_ACCUM = 15
+
+      # Matrix layout attributes
+      CUBLASLT_MATRIX_LAYOUT_TYPE = 0
+      CUBLASLT_MATRIX_LAYOUT_ORDER = 1
+      CUBLASLT_MATRIX_LAYOUT_ROWS = 2
+      CUBLASLT_MATRIX_LAYOUT_COLS = 3
+      CUBLASLT_MATRIX_LAYOUT_LD = 4
+      CUBLASLT_MATRIX_LAYOUT_BATCH_COUNT = 5
+      CUBLASLT_MATRIX_LAYOUT_STRIDED_BATCH_OFFSET = 6
+      CUBLASLT_MATRIX_LAYOUT_PLANE_OFFSET = 7
+
+      # Matmul preference attributes
+      CUBLASLT_MATMUL_PREF_SEARCH_MODE = 0
+      CUBLASLT_MATMUL_PREF_MAX_WORKSPACE_BYTES = 1
+      CUBLASLT_MATMUL_PREF_REDUCTION_SCHEME_MASK = 3
+      CUBLASLT_MATMUL_PREF_MIN_ALIGNMENT_A_BYTES = 5
+      CUBLASLT_MATMUL_PREF_MIN_ALIGNMENT_B_BYTES = 6
+      CUBLASLT_MATMUL_PREF_MIN_ALIGNMENT_C_BYTES = 7
+      CUBLASLT_MATMUL_PREF_MIN_ALIGNMENT_D_BYTES = 8
+      CUBLASLT_MATMUL_PREF_MAX_WAVES_COUNT = 9
+      CUBLASLT_MATMUL_PREF_IMPL_MASK = 10
+      CUBLASLT_MATMUL_PREF_SM_COUNT_TARGET = 14
+
+      # Search modes
+      CUBLASLT_SEARCH_BEST_FIT = 0
+      CUBLASLT_SEARCH_LIMITED_BY_ALGO_ID = 1
+
+      # Numerical implementation flags for IMPL_MASK
+      CUBLASLT_NUMERICAL_IMPL_FLAGS_FMA = 0x01
+      CUBLASLT_NUMERICAL_IMPL_FLAGS_HMMA = 0x02
+      CUBLASLT_NUMERICAL_IMPL_FLAGS_IMMA = 0x04
+      CUBLASLT_NUMERICAL_IMPL_FLAGS_DMMA = 0x08
+      CUBLASLT_NUMERICAL_IMPL_FLAGS_TENSOR_OP_MASK = 0x0E
+
+      # Reduction schemes
+      CUBLASLT_REDUCTION_SCHEME_NONE = 0
+      CUBLASLT_REDUCTION_SCHEME_INPLACE = 1
+      CUBLASLT_REDUCTION_SCHEME_COMPUTE_TYPE = 2
+      CUBLASLT_REDUCTION_SCHEME_OUTPUT_TYPE = 4
+      CUBLASLT_REDUCTION_SCHEME_MASK = 7
+
+      # Epilogue operations
+      CUBLASLT_EPILOGUE_DEFAULT = 1
+      CUBLASLT_EPILOGUE_RELU = 2
+      CUBLASLT_EPILOGUE_BIAS = 4
+      CUBLASLT_EPILOGUE_RELU_BIAS = 6
+      CUBLASLT_EPILOGUE_GELU = 32
+      CUBLASLT_EPILOGUE_GELU_BIAS = 36
+
+      # CUDA data types (for compatibility)
+      CUDA_R_16F = 2   # FP16
+      CUDA_R_32F = 0   # FP32
+      CUDA_R_64F = 1   # FP64
+      CUDA_R_16BF = 14 # BF16
+      CUDA_R_8F_E4M3 = 28  # FP8 E4M3
+      CUDA_R_8F_E5M2 = 29  # FP8 E5M2
+
+      # ==========================================================================
+      # Heuristic result structure
+      # ==========================================================================
+
+      # cublasLtMatmulHeuristicResult_t
+      class MatmulHeuristicResult < FFI::Struct
+        layout :algo, [:uint8, 64],         # cublasLtMatmulAlgo_t (opaque, 64 bytes)
+               :workspaceSize, :size_t,
+               :state, :int,                # cublasStatus_t
+               :wavesCount, :float,
+               :reserved, [:int, 4]
+      end
+
+      # ==========================================================================
+      # Library state
+      # ==========================================================================
+
+      @loaded = false
+      @lt_handle = nil
+      @workspace_ptr = nil
+      @workspace_size = 0
+
+      class << self
+        # @return [FFI::Pointer, nil] cuBLASLt handle
+        attr_accessor :lt_handle
+
+        # @return [FFI::Pointer, nil] Workspace memory
+        attr_accessor :workspace_ptr
+
+        # @return [Integer] Workspace size in bytes
+        attr_accessor :workspace_size
+
+        # Ensure cuBLASLt is loaded
+        # @return [void]
+        def ensure_loaded!
+          return if @loaded
+
+          cuda_bin = Ignis.configuration.cuda_bin_path
+          if cuda_bin
+            dll_path = Dir.glob(File.join(cuda_bin, "cublasLt64_*.dll")).max
+            ffi_lib dll_path if dll_path
+          else
+            ffi_lib "cublasLt64_12"
+          end
+
+          attach_cublaslt_functions!
+          initialize_cublaslt!
+
+          @loaded = true
+        end
+
+        # Get or create cuBLASLt handle
+        # @return [FFI::Pointer]
+        def get_handle
+          ensure_loaded!
+          @lt_handle
+        end
+
+        # Get or allocate workspace
+        # @param min_size [Integer] Minimum workspace size in bytes
+        # @return [FFI::Pointer] Workspace pointer
+        def get_workspace(min_size = 256 * 1024 * 1024)
+          ensure_loaded!
+
+          if @workspace_ptr.nil? || @workspace_size < min_size
+            # Free existing workspace
+            CUDA::RuntimeAPI.cudaFree(@workspace_ptr) if @workspace_ptr
+
+            # Allocate new workspace
+            ptr_ptr = FFI::MemoryPointer.new(:pointer)
+            status = CUDA::RuntimeAPI.cudaMalloc(ptr_ptr, min_size)
+            if status.zero?
+              @workspace_ptr = ptr_ptr.read_pointer
+              @workspace_size = min_size
+              Ignis.logger.info { "cuBLASLt workspace allocated: #{min_size / 1024 / 1024}MB" }
+            else
+              Ignis.logger.warn { "Failed to allocate cuBLASLt workspace: #{status}" }
+              @workspace_ptr = FFI::Pointer::NULL
+              @workspace_size = 0
+            end
+          end
+
+          @workspace_ptr
+        end
+
+        # Finalize cuBLASLt
+        # @return [void]
+        def finalize!
+          if @workspace_ptr && !@workspace_ptr.null?
+            CUDA::RuntimeAPI.cudaFree(@workspace_ptr) rescue nil
+            @workspace_ptr = nil
+            @workspace_size = 0
+          end
+
+          if @lt_handle
+            cublasLtDestroy(@lt_handle) rescue nil
+            @lt_handle = nil
+          end
+
+          @loaded = false
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def attach_cublaslt_functions!
+          # Handle management
+          attach_function :cublasLtCreate, [:pointer], :int
+          attach_function :cublasLtDestroy, [:pointer], :int
+
+          # Matmul descriptor
+          attach_function :cublasLtMatmulDescCreate, [:pointer, :int, :int], :int
+          attach_function :cublasLtMatmulDescDestroy, [:pointer], :int
+          attach_function :cublasLtMatmulDescSetAttribute, [:pointer, :int, :pointer, :size_t], :int
+          attach_function :cublasLtMatmulDescGetAttribute, [:pointer, :int, :pointer, :size_t, :pointer], :int
+
+          # Matrix layout descriptor
+          attach_function :cublasLtMatrixLayoutCreate, [:pointer, :int, :uint64, :uint64, :int64], :int
+          attach_function :cublasLtMatrixLayoutDestroy, [:pointer], :int
+          attach_function :cublasLtMatrixLayoutSetAttribute, [:pointer, :int, :pointer, :size_t], :int
+          attach_function :cublasLtMatrixLayoutGetAttribute, [:pointer, :int, :pointer, :size_t, :pointer], :int
+
+          # Matmul preference
+          attach_function :cublasLtMatmulPreferenceCreate, [:pointer], :int
+          attach_function :cublasLtMatmulPreferenceDestroy, [:pointer], :int
+          attach_function :cublasLtMatmulPreferenceSetAttribute, [:pointer, :int, :pointer, :size_t], :int
+          attach_function :cublasLtMatmulPreferenceGetAttribute, [:pointer, :int, :pointer, :size_t, :pointer], :int
+
+          # Algorithm heuristic
+          attach_function :cublasLtMatmulAlgoGetHeuristic, [
+            :pointer,  # lightHandle
+            :pointer,  # operationDesc
+            :pointer,  # Adesc
+            :pointer,  # Bdesc
+            :pointer,  # Cdesc
+            :pointer,  # Ddesc
+            :pointer,  # preference
+            :int,      # requestedAlgoCount
+            :pointer,  # heuristicResultsArray (array of MatmulHeuristicResult)
+            :pointer   # returnAlgoCount
+          ], :int
+
+          # Matrix multiplication
+          attach_function :cublasLtMatmul, [
+            :pointer,  # lightHandle
+            :pointer,  # computeDesc
+            :pointer,  # alpha
+            :pointer,  # A
+            :pointer,  # Adesc
+            :pointer,  # B
+            :pointer,  # Bdesc
+            :pointer,  # beta
+            :pointer,  # C
+            :pointer,  # Cdesc
+            :pointer,  # D
+            :pointer,  # Ddesc
+            :pointer,  # algo (cublasLtMatmulAlgo_t)
+            :pointer,  # workspace
+            :size_t,   # workspaceSizeInBytes
+            :pointer   # stream
+          ], :int
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def initialize_cublaslt!
+          handle_ptr = FFI::MemoryPointer.new(:pointer)
+          status = cublasLtCreate(handle_ptr)
+
+          if status.zero?
+            @lt_handle = handle_ptr.read_pointer
+            Ignis.logger.info { "cuBLASLt initialized successfully" }
+          else
+            raise CuBLASError.new("Failed to initialize cuBLASLt", code: status)
+          end
+        end
+      end
+
+      # ==========================================================================
+      # Helper Methods
+      # ==========================================================================
+
+      # Convert dtype symbol to CUDA data type
+      # @param dtype [Symbol] Data type (:float16, :float32, :float64)
+      # @return [Integer] CUDA data type constant
+      def self.dtype_to_cuda_type(dtype)
+        case dtype
+        when :float16, :half then CUDA_R_16F
+        when :float32, :float then CUDA_R_32F
+        when :float64, :double then CUDA_R_64F
+        when :bfloat16 then CUDA_R_16BF
+        else CUDA_R_32F
+        end
+      end
+
+      # Get compute type for dtype
+      # @param dtype [Symbol] Data type
+      # @return [Integer] Compute type constant
+      def self.compute_type_for_dtype(dtype)
+        case dtype
+        when :float16, :half
+          CuBLASBindings::CUBLAS_COMPUTE_32F_FAST_16F
+        when :float32, :float
+          CuBLASBindings::CUBLAS_COMPUTE_32F_FAST_TF32
+        when :float64, :double
+          CuBLASBindings::CUBLAS_COMPUTE_64F
+        else
+          CuBLASBindings::CUBLAS_COMPUTE_32F
+        end
+      end
+
+      # Get scale type for dtype (type of alpha/beta scalars)
+      #
+      # Per NVIDIA cuBLAS documentation, scaleType must match the accumulator type:
+      # - CUBLAS_COMPUTE_32F_FAST_16F requires CUDA_R_32F scale type
+      # - CUBLAS_COMPUTE_32F_FAST_TF32 requires CUDA_R_32F scale type
+      # - CUBLAS_COMPUTE_64F requires CUDA_R_64F scale type
+      #
+      # @param dtype [Symbol] Data type of input matrices
+      # @return [Integer] CUDA scale type constant for alpha/beta
+      def self.scale_type_for_dtype(dtype)
+        case dtype
+        when :float64, :double
+          CUDA_R_64F
+        else
+          # FP16, BF16, FP32, TF32 all use FP32 accumulation and require FP32 scale type
+          CUDA_R_32F
+        end
+      end
+
+      # Check status and raise error if not success
+      # @param status [Integer] cuBLAS status code
+      # @param context [String] Context for error message
+      # @return [void]
+      def self.check_status!(status, context = "cuBLASLt operation")
+        return if status.zero?
+
+        raise CuBLASError.new("#{context}: status=#{status}", code: status)
+      end
+    end
+  end
+end

data/lib/nvruby/linalg/epilog.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ignis
+  module LinAlg
+    # Epilog operations for fused GEMM
+    module Epilog
+      # Available epilog types
+      TYPES = {
+        default: CuBLASBindings::CUBLASLT_EPILOGUE_DEFAULT,
+        relu: CuBLASBindings::CUBLASLT_EPILOGUE_RELU,
+        relu_aux: CuBLASBindings::CUBLASLT_EPILOGUE_RELU_AUX,
+        bias: CuBLASBindings::CUBLASLT_EPILOGUE_BIAS,
+        relu_bias: CuBLASBindings::CUBLASLT_EPILOGUE_RELU_BIAS,
+        relu_aux_bias: CuBLASBindings::CUBLASLT_EPILOGUE_RELU_AUX_BIAS,
+        drelu: CuBLASBindings::CUBLASLT_EPILOGUE_DRELU,
+        drelu_bgrad: CuBLASBindings::CUBLASLT_EPILOGUE_DRELU_BGRAD,
+        gelu: CuBLASBindings::CUBLASLT_EPILOGUE_GELU,
+        gelu_aux: CuBLASBindings::CUBLASLT_EPILOGUE_GELU_AUX,
+        gelu_bias: CuBLASBindings::CUBLASLT_EPILOGUE_GELU_BIAS,
+        gelu_aux_bias: CuBLASBindings::CUBLASLT_EPILOGUE_GELU_AUX_BIAS,
+        dgelu: CuBLASBindings::CUBLASLT_EPILOGUE_DGELU,
+        dgelu_bgrad: CuBLASBindings::CUBLASLT_EPILOGUE_DGELU_BGRAD,
+        bgrada: CuBLASBindings::CUBLASLT_EPILOGUE_BGRADA,
+        bgradb: CuBLASBindings::CUBLASLT_EPILOGUE_BGRADB
+      }.freeze
+
+      class << self
+        # Get epilog type constant
+        # @param type [Symbol] Epilog type
+        # @return [Integer] cuBLASLt epilog constant
+        def get(type)
+          constant = TYPES[type]
+          raise ArgumentError, "Unknown epilog type: #{type}" unless constant
+
+          constant
+        end
+
+        # List available epilog types
+        # @return [Array<Symbol>]
+        def available
+          TYPES.keys
+        end
+
+        # Check if epilog type supports bias
+        # @param type [Symbol] Epilog type
+        # @return [Boolean]
+        def supports_bias?(type)
+          %i[bias relu_bias relu_aux_bias gelu_bias gelu_aux_bias].include?(type)
+        end
+
+        # Check if epilog type supports auxiliary output
+        # @param type [Symbol] Epilog type
+        # @return [Boolean]
+        def supports_aux?(type)
+          %i[relu_aux relu_aux_bias gelu_aux gelu_aux_bias].include?(type)
+        end
+
+        # Check if epilog type is for backward pass
+        # @param type [Symbol] Epilog type
+        # @return [Boolean]
+        def backward?(type)
+          %i[drelu drelu_bgrad dgelu dgelu_bgrad bgrada bgradb].include?(type)
+        end
+      end
+    end
+  end
+end