ignis 0.0.1

data/lib/nvruby/cuda/stream.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+
+module Ignis
+  module CUDA
+    # CUDA stream for asynchronous operations.
+    #
+    # Refactored to use Fiddle-based RuntimeAPI methods.
+    class Stream
+      # @return [Fiddle::Pointer] Stream handle
+      attr_reader :handle
+
+      # Default stream singleton
+      DEFAULT = :default
+
+      # @param synchronous [Boolean] If true, creates a synchronous stream
+      def initialize(synchronous: false)
+        @synchronous = synchronous
+        @handle = create_stream
+        @destroyed = false
+
+        unless @synchronous
+          captured_handle = @handle
+          ObjectSpace.define_finalizer(self, self.class.release_finalizer(captured_handle))
+        end
+      end
+
+      # @return [Fiddle::Pointer] for interop
+      def to_ptr
+        @handle
+      end
+
+      # Check if stream is the default stream.
+      # @return [Boolean]
+      def default?
+        @handle.nil? || @handle.to_i.zero?
+      end
+
+      # @return [Boolean]
+      def destroyed?
+        @destroyed
+      end
+
+      # Synchronize the stream (wait for all operations to complete).
+      # @return [void]
+      def synchronize
+        return if @destroyed || default?
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.stream_synchronize(@handle)
+      end
+
+      # Query if stream has completed.
+      # @return [Boolean]
+      def completed?
+        return true if @destroyed || default?
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.stream_query(@handle)
+      end
+
+      # Destroy the stream.
+      # @return [void]
+      def destroy!
+        return if @destroyed || default?
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.stream_destroy(@handle)
+
+        @destroyed = true
+        ObjectSpace.undefine_finalizer(self)
+      end
+
+      # @return [String]
+      def to_s
+        return 'CudaStream[default]' if default?
+        return 'CudaStream[destroyed]' if @destroyed
+
+        "CudaStream[0x#{@handle.to_i.to_s(16)}]"
+      end
+
+      class << self
+        # Get the default (null) stream.
+        # @return [Stream]
+        def default
+          @default_stream ||= DefaultStream.new
+        end
+
+        # Create a finalizer for stream cleanup.
+        # @param handle [Fiddle::Pointer]
+        # @return [Proc]
+        def release_finalizer(handle)
+          handle_addr = handle.to_i
+          proc do
+            next if handle_addr.zero?
+
+            begin
+              RuntimeAPI.ensure_loaded!
+              RuntimeAPI.stream_destroy(Fiddle::Pointer.new(handle_addr))
+            rescue StandardError
+              # Silently ignore errors during finalization
+            end
+          end
+        end
+      end
+
+      private
+
+      # Create a CUDA stream.
+      # @return [Fiddle::Pointer]
+      def create_stream
+        return Fiddle::Pointer.new(0) if @synchronous
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.stream_create
+      end
+    end
+
+    # Default stream that wraps the null stream.
+    class DefaultStream < Stream
+      def initialize
+        @handle = Fiddle::Pointer.new(0)
+        @destroyed = false
+        @synchronous = true
+      end
+
+      def destroy!
+        # Cannot destroy default stream
+      end
+
+      def default?
+        true
+      end
+    end
+
+    # CUDA event for timing and synchronization.
+    #
+    # Refactored to use Fiddle-based RuntimeAPI methods.
+    class Event
+      # @return [Fiddle::Pointer] Event handle
+      attr_reader :handle
+
+      # @param blocking [Boolean] If true, CPU will block on synchronize
+      # @param disable_timing [Boolean] If true, timing is disabled for better performance
+      def initialize(blocking: false, disable_timing: false)
+        @blocking = blocking
+        @disable_timing = disable_timing
+        @handle = create_event
+        @destroyed = false
+
+        captured_handle = @handle
+        ObjectSpace.define_finalizer(self, self.class.release_finalizer(captured_handle))
+      end
+
+      # @return [Boolean]
+      def destroyed?
+        @destroyed
+      end
+
+      # Record the event on a stream.
+      # @param stream [Stream, nil] Stream to record on (nil for default)
+      # @return [void]
+      def record(stream: nil)
+        raise InvalidOperationError, 'Event has been destroyed' if @destroyed
+
+        RuntimeAPI.ensure_loaded!
+        stream_handle = stream&.to_ptr || Fiddle::Pointer.new(0)
+        RuntimeAPI.event_record(@handle, stream_handle)
+      end
+
+      # Wait for the event to complete.
+      # @return [void]
+      def synchronize
+        raise InvalidOperationError, 'Event has been destroyed' if @destroyed
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.event_synchronize(@handle)
+      end
+
+      # @return [Fiddle::Pointer]
+      def to_ptr
+        @handle
+      end
+
+      # Calculate elapsed time between two events.
+      # @param start_event [Event] Start event
+      # @param end_event [Event] End event
+      # @return [Float] Elapsed time in milliseconds
+      def self.elapsed_time(start_event, end_event)
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.event_elapsed_time(start_event.handle, end_event.handle)
+      end
+
+      # Destroy the event.
+      # @return [void]
+      def destroy!
+        return if @destroyed
+
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.event_destroy(@handle)
+
+        @destroyed = true
+        ObjectSpace.undefine_finalizer(self)
+      end
+
+      class << self
+        # Create a finalizer for event cleanup.
+        # @param handle [Fiddle::Pointer]
+        # @return [Proc]
+        def release_finalizer(handle)
+          handle_addr = handle.to_i
+          proc do
+            begin
+              RuntimeAPI.ensure_loaded!
+              RuntimeAPI.event_destroy(Fiddle::Pointer.new(handle_addr))
+            rescue StandardError
+              # Silently ignore errors during finalization
+            end
+          end
+        end
+      end
+
+      private
+
+      # Create a CUDA event.
+      # @return [Fiddle::Pointer]
+      def create_event
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.event_create
+      end
+    end
+  end
+end

data/lib/nvruby/dtype.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Ignis
+  # Supported data types with their properties
+  module DType
+    # Data type definitions with byte size and FFI type
+    TYPES = {
+      float16: { bytes: 2, ffi: :uint16, cuda: 2, complex: false },   # CUDA_R_16F (stored as uint16)
+      bfloat16: { bytes: 2, ffi: :uint16, cuda: 14, complex: false }, # CUDA_R_16BF (stored as uint16)
+      float32: { bytes: 4, ffi: :float, cuda: 0, complex: false },
+      float64: { bytes: 8, ffi: :double, cuda: 1, complex: false },
+      int8: { bytes: 1, ffi: :int8, cuda: 3, complex: false },
+      int16: { bytes: 2, ffi: :int16, cuda: 8, complex: false },
+      int32: { bytes: 4, ffi: :int32, cuda: 10, complex: false },
+      int64: { bytes: 8, ffi: :int64, cuda: 11, complex: false },
+      uint8: { bytes: 1, ffi: :uint8, cuda: 17, complex: false },
+      uint16: { bytes: 2, ffi: :uint16, cuda: 18, complex: false },
+      uint32: { bytes: 4, ffi: :uint32, cuda: 19, complex: false },
+      uint64: { bytes: 8, ffi: :uint64, cuda: 20, complex: false },
+      complex64: { bytes: 8, ffi: :float, cuda: 4, complex: true },   # 2x float32
+      complex128: { bytes: 16, ffi: :double, cuda: 5, complex: true } # 2x float64
+    }.freeze
+
+    # cuBLAS data type constants (cudaDataType_t values)
+    CUBLAS_TYPES = {
+      float16: 2,     # CUDA_R_16F
+      bfloat16: 14,   # CUDA_R_16BF
+      float32: 0,     # CUDA_R_32F
+      float64: 1,     # CUDA_R_64F
+      complex64: 4,   # CUDA_C_32F
+      complex128: 5,  # CUDA_C_64F
+      int8: 3,        # CUDA_R_8I
+      int32: 10       # CUDA_R_32I
+    }.freeze
+
+    class << self
+      # Get byte size for a dtype
+      # @param dtype [Symbol] Data type
+      # @return [Integer] Size in bytes
+      def byte_size(dtype)
+        info = TYPES[dtype]
+        raise UnsupportedDTypeError, dtype unless info
+
+        info[:bytes]
+      end
+
+      # Get FFI type for a dtype
+      # @param dtype [Symbol] Data type
+      # @return [Symbol] FFI type symbol
+      def ffi_type(dtype)
+        info = TYPES[dtype]
+        raise UnsupportedDTypeError, dtype unless info
+
+        info[:ffi]
+      end
+
+      # Check if dtype is complex
+      # @param dtype [Symbol] Data type
+      # @return [Boolean]
+      def complex?(dtype)
+        info = TYPES[dtype]
+        raise UnsupportedDTypeError, dtype unless info
+
+        info[:complex]
+      end
+
+      # Check if dtype is floating point
+      # @param dtype [Symbol] Data type
+      # @return [Boolean]
+      def float?(dtype)
+        %i[float16 bfloat16 float32 float64 complex64 complex128].include?(dtype)
+      end
+
+      # Check if dtype is integer
+      # @param dtype [Symbol] Data type
+      # @return [Boolean]
+      def integer?(dtype)
+        %i[int8 int16 int32 int64 uint8 uint16 uint32 uint64].include?(dtype)
+      end
+
+      # Check if dtype is signed
+      # @param dtype [Symbol] Data type
+      # @return [Boolean]
+      def signed?(dtype)
+        !%i[uint8 uint16 uint32 uint64].include?(dtype)
+      end
+
+      # Get cuBLAS type constant
+      # @param dtype [Symbol] Data type
+      # @return [Integer] cuBLAS type constant
+      def cublas_type(dtype)
+        type = CUBLAS_TYPES[dtype]
+        raise UnsupportedDTypeError.new(dtype, operation: "cuBLAS") unless type
+
+        type
+      end
+
+      # Validate dtype
+      # @param dtype [Symbol] Data type to validate
+      # @return [Symbol] Validated dtype
+      # @raise [UnsupportedDTypeError] If dtype is not valid
+      def validate!(dtype)
+        raise UnsupportedDTypeError, dtype unless TYPES.key?(dtype)
+
+        dtype
+      end
+
+      # List all supported dtypes
+      # @return [Array<Symbol>] All dtype symbols
+      def all
+        TYPES.keys
+      end
+
+      # Get real component dtype for complex types
+      # @param dtype [Symbol] Complex data type
+      # @return [Symbol] Real component dtype
+      def real_dtype(dtype)
+        case dtype
+        when :complex64 then :float32
+        when :complex128 then :float64
+        else dtype
+        end
+      end
+
+      # Get complex dtype for real types
+      # @param dtype [Symbol] Real data type
+      # @return [Symbol] Complex dtype
+      def complex_dtype(dtype)
+        case dtype
+        when :float32 then :complex64
+        when :float64 then :complex128
+        when :complex64, :complex128 then dtype
+        else
+          raise UnsupportedDTypeError.new(dtype, operation: "complex conversion")
+        end
+      end
+    end
+  end
+end