ignis 0.0.1

data/lib/nvruby/cuda/device.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Ignis
+  module CUDA
+    # CUDA device attribute constants (cudaDeviceAttr enum values)
+    module DeviceAttribute
+      MAX_THREADS_PER_BLOCK = 1
+      MAX_BLOCK_DIM_X = 2
+      MAX_BLOCK_DIM_Y = 3
+      MAX_BLOCK_DIM_Z = 4
+      MAX_GRID_DIM_X = 5
+      MAX_GRID_DIM_Y = 6
+      MAX_GRID_DIM_Z = 7
+      MAX_SHARED_MEMORY_PER_BLOCK = 8
+      TOTAL_CONSTANT_MEMORY = 9
+      WARP_SIZE = 10
+      MAX_PITCH = 11
+      MAX_REGISTERS_PER_BLOCK = 12
+      CLOCK_RATE = 13
+      TEXTURE_ALIGNMENT = 14
+      MULTIPROCESSOR_COUNT = 16
+      KERNEL_EXEC_TIMEOUT = 17
+      INTEGRATED = 18
+      CAN_MAP_HOST_MEMORY = 19
+      COMPUTE_MODE = 20
+      CONCURRENT_KERNELS = 31
+      ECC_ENABLED = 32
+      MEMORY_CLOCK_RATE = 36
+      GLOBAL_MEMORY_BUS_WIDTH = 37
+      L2_CACHE_SIZE = 38
+      MAX_THREADS_PER_MULTIPROCESSOR = 39
+      ASYNC_ENGINE_COUNT = 40
+      UNIFIED_ADDRESSING = 41
+      COMPUTE_CAPABILITY_MAJOR = 75
+      COMPUTE_CAPABILITY_MINOR = 76
+      MANAGED_MEMORY = 83
+      COOPERATIVE_LAUNCH = 95
+      MAX_BLOCKS_PER_MULTIPROCESSOR = 106
+      GPU_DIRECT_RDMA_SUPPORTED = 116
+      MEMORY_POOLS_SUPPORTED = 115
+    end
+
+    # Represents a CUDA GPU device.
+    #
+    # Uses RuntimeAPI (Fiddle-based) for hot-path attribute queries
+    # and DeviceProperties (FFI::Struct) for full device property reads.
+    class Device
+      # @return [Integer] Device index
+      attr_reader :index
+
+      # @param index [Integer] Device index
+      def initialize(index)
+        @index = index
+        @attribute_cache = {}
+        @name = nil
+        @total_memory = nil
+        @props_cache = nil
+      end
+
+      # @return [String] Device name
+      def name
+        return @name if @name
+
+        @name = properties[:name]
+      end
+
+      # @return [Integer] Total global memory in bytes
+      def total_memory
+        return @total_memory if @total_memory
+
+        @total_memory = memory_info[:total_bytes]
+      end
+
+      # @return [Integer] Shared memory per block in bytes
+      def shared_memory_per_block
+        get_attribute(DeviceAttribute::MAX_SHARED_MEMORY_PER_BLOCK)
+      end
+
+      # @return [Integer] Number of streaming multiprocessors
+      def multiprocessor_count
+        get_attribute(DeviceAttribute::MULTIPROCESSOR_COUNT)
+      end
+
+      # @return [Integer] Warp size (typically 32)
+      def warp_size
+        get_attribute(DeviceAttribute::WARP_SIZE)
+      end
+
+      # @return [String] Compute capability as "major.minor"
+      def compute_capability
+        "#{compute_capability_major}.#{compute_capability_minor}"
+      end
+
+      # @return [Integer] Major compute capability
+      def compute_capability_major
+        get_attribute(DeviceAttribute::COMPUTE_CAPABILITY_MAJOR)
+      end
+
+      # @return [Integer] Minor compute capability
+      def compute_capability_minor
+        get_attribute(DeviceAttribute::COMPUTE_CAPABILITY_MINOR)
+      end
+
+      # @return [Integer] Max threads per block
+      def max_threads_per_block
+        get_attribute(DeviceAttribute::MAX_THREADS_PER_BLOCK)
+      end
+
+      # @return [Array<Integer>] Max threads per dimension [x, y, z]
+      def max_threads_dim
+        [
+          get_attribute(DeviceAttribute::MAX_BLOCK_DIM_X),
+          get_attribute(DeviceAttribute::MAX_BLOCK_DIM_Y),
+          get_attribute(DeviceAttribute::MAX_BLOCK_DIM_Z)
+        ]
+      end
+
+      # @return [Array<Integer>] Max grid size [x, y, z]
+      def max_grid_size
+        [
+          get_attribute(DeviceAttribute::MAX_GRID_DIM_X),
+          get_attribute(DeviceAttribute::MAX_GRID_DIM_Y),
+          get_attribute(DeviceAttribute::MAX_GRID_DIM_Z)
+        ]
+      end
+
+      # @return [Integer] Clock rate in kHz
+      def clock_rate
+        get_attribute(DeviceAttribute::CLOCK_RATE)
+      end
+
+      # @return [Integer] Memory clock rate in kHz
+      def memory_clock_rate
+        get_attribute(DeviceAttribute::MEMORY_CLOCK_RATE)
+      end
+
+      # @return [Integer] Memory bus width in bits
+      def memory_bus_width
+        get_attribute(DeviceAttribute::GLOBAL_MEMORY_BUS_WIDTH)
+      end
+
+      # @return [Integer] L2 cache size in bytes
+      def l2_cache_size
+        get_attribute(DeviceAttribute::L2_CACHE_SIZE)
+      end
+
+      # @return [Boolean] Whether ECC memory is enabled
+      def ecc_enabled?
+        get_attribute(DeviceAttribute::ECC_ENABLED) != 0
+      end
+
+      # @return [Boolean] Whether concurrent kernels are supported
+      def concurrent_kernels?
+        get_attribute(DeviceAttribute::CONCURRENT_KERNELS) != 0
+      end
+
+      # @return [Boolean] Whether unified addressing is supported
+      def unified_addressing?
+        get_attribute(DeviceAttribute::UNIFIED_ADDRESSING) != 0
+      end
+
+      # @return [Boolean] Whether managed memory is supported
+      def managed_memory?
+        get_attribute(DeviceAttribute::MANAGED_MEMORY) != 0
+      end
+
+      # @return [Boolean] Whether cooperative launch is supported
+      def cooperative_launch?
+        get_attribute(DeviceAttribute::COOPERATIVE_LAUNCH) != 0
+      end
+
+      # Get available and total memory via RuntimeAPI (Fiddle hot path).
+      # @return [Hash] {free_bytes:, total_bytes:}
+      def memory_info
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.set_device(@index)
+        RuntimeAPI.mem_get_info
+      end
+
+      # @return [Integer] Free memory in bytes
+      def free_memory
+        memory_info[:free_bytes]
+      end
+
+      # Get full device properties via DeviceProperties (FFI::Struct).
+      # Cached after first call.
+      # @return [Hash] device property summary
+      def properties
+        @props_cache ||= DeviceProperties.summary(@index)
+      end
+
+      # Set this device as the current device.
+      # @return [void]
+      def set_current!
+        RuntimeAPI.ensure_loaded!
+        RuntimeAPI.set_device(@index)
+      end
+
+      # Synchronize this device.
+      # @return [void]
+      def synchronize
+        set_current!
+        RuntimeAPI.device_synchronize
+      end
+
+      # Reset this device.
+      # @return [void]
+      def reset!
+        set_current!
+        RuntimeAPI.device_reset
+      end
+
+      # @return [String] Human-readable device description
+      def to_s
+        mem_mb = total_memory / (1024 * 1024)
+        "Device[#{@index}]: #{name} (CC #{compute_capability}, #{mem_mb} MB)"
+      end
+
+      # @return [String] Detailed inspection
+      def inspect
+        "#<Ignis::CUDA::Device:#{object_id} index=#{@index} name=#{name.inspect} " \
+          "compute=#{compute_capability} memory=#{total_memory}>"
+      end
+
+      class << self
+        # Get the number of CUDA devices.
+        # @return [Integer]
+        def count
+          RuntimeAPI.ensure_loaded!
+          RuntimeAPI.get_device_count
+        end
+
+        # List all available devices.
+        # @return [Array<Device>]
+        def list
+          count.times.map { |i| new(i) }
+        end
+
+        # Get the current device.
+        # @return [Device]
+        def current
+          RuntimeAPI.ensure_loaded!
+          new(RuntimeAPI.get_device)
+        end
+
+        # Get the default device from configuration.
+        # @return [Device]
+        def default
+          new(Ignis.configuration.default_device)
+        end
+
+        # Check if any CUDA device is available.
+        # @return [Boolean]
+        def available?
+          count.positive?
+        rescue CudaRuntimeError
+          false
+        end
+      end
+
+      private
+
+      # Get a device attribute value (cached).
+      # Uses RuntimeAPI.device_get_attribute (Fiddle hot path).
+      # @param attribute [Integer] Attribute constant from DeviceAttribute
+      # @return [Integer] Attribute value
+      def get_attribute(attribute)
+        return @attribute_cache[attribute] if @attribute_cache.key?(attribute)
+
+        RuntimeAPI.ensure_loaded!
+        @attribute_cache[attribute] = RuntimeAPI.device_get_attribute(attribute, @index)
+      end
+    end
+  end
+end

data/lib/nvruby/cuda/device_props.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+# CUDA Device Properties — FFI::Struct definition
+#
+# Rule 4: FFI structs live in their own file, never mixed with Fiddle hot-path calls.
+# This file is used by device.rb for one-shot property reads.
+#
+# cuDeviceProp has 268+ fields. We define the most commonly used subset
+# and provide a raw accessor for the rest.
+
+require_relative '../../nnw/shared/ffi_loader'
+Ignis::Shared::FFILoader.load!
+
+module Ignis
+  module CUDA
+    # cudaDeviceProp struct for FFI binding.
+    #
+    # This covers the essential fields. For the full struct, use raw_props.
+    module DeviceProperties
+      extend FFI::Library
+
+      # Resolve CUDA runtime library path per platform.
+      CUDART_PATH = if defined?(Ignis::Platform)
+                      Ignis::Platform.cudart_path
+                    elsif RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+                      File.join('C:', 'Program Files', 'NVIDIA GPU Computing Toolkit',
+                                'CUDA', 'v13.0', 'bin', 'cudart64_130.dll')
+                    else
+                      'libcudart.so.13'
+                    end
+
+      begin
+        ffi_lib CUDART_PATH
+      rescue LoadError => e
+        $stderr.puts "[Ignis] WARNING: Cannot load #{CUDART_PATH}: #{e.message}"
+      end
+
+      # cudaDeviceProp struct definition — essential fields.
+      #
+      # The full struct is ~2KB. We define the first ~80 fields that are
+      # most commonly queried. Remaining bytes are padded.
+      class CudaDeviceProp < FFI::Struct
+        # The struct layout matches CUDA 12.x / 13.x cudaDeviceProp ordering.
+        # Field names match the CUDA documentation exactly.
+        layout \
+          :name,                               [:char, 256],    # Device name
+          :uuid,                               [:char, 16],     # 16-byte UUID
+          :luid,                               [:char, 8],      # 8-byte LUID
+          :luidDeviceNodeMask,                 :uint,
+          :totalGlobalMem,                     :size_t,
+          :sharedMemPerBlock,                  :size_t,
+          :regsPerBlock,                       :int,
+          :warpSize,                           :int,
+          :memPitch,                           :size_t,
+          :maxThreadsPerBlock,                 :int,
+          :maxThreadsDim,                      [:int, 3],
+          :maxGridSize,                        [:int, 3],
+          :clockRate,                          :int,
+          :totalConstMem,                      :size_t,
+          :major,                              :int,            # Compute capability major
+          :minor,                              :int,            # Compute capability minor
+          :textureAlignment,                   :size_t,
+          :texturePitchAlignment,              :size_t,
+          :deviceOverlap,                      :int,
+          :multiProcessorCount,                :int,
+          :kernelExecTimeoutEnabled,           :int,
+          :integrated,                         :int,
+          :canMapHostMemory,                   :int,
+          :computeMode,                        :int,
+          :maxTexture1D,                       :int,
+          :maxTexture1DMipmap,                 :int,
+          :maxTexture1DLinear,                 :int,
+          :maxTexture2D,                       [:int, 2],
+          :maxTexture2DMipmap,                 [:int, 2],
+          :maxTexture2DLinear,                 [:int, 3],
+          :maxTexture2DGather,                 [:int, 2],
+          :maxTexture3D,                       [:int, 3],
+          :maxTexture3DAlt,                    [:int, 3],
+          :maxTextureCubemap,                  :int,
+          :maxTexture1DLayered,                [:int, 2],
+          :maxTexture2DLayered,                [:int, 3],
+          :maxTextureCubemapLayered,           [:int, 2],
+          :maxSurface1D,                       :int,
+          :maxSurface2D,                       [:int, 2],
+          :maxSurface3D,                       [:int, 3],
+          :maxSurface1DLayered,                [:int, 2],
+          :maxSurface2DLayered,                [:int, 3],
+          :maxSurfaceCubemap,                  :int,
+          :maxSurfaceCubemapLayered,           [:int, 2],
+          :surfaceAlignment,                   :size_t,
+          :concurrentKernels,                  :int,
+          :ECCEnabled,                         :int,
+          :pciBusID,                           :int,
+          :pciDeviceID,                        :int,
+          :pciDomainID,                        :int,
+          :tccDriver,                          :int,
+          :asyncEngineCount,                   :int,
+          :unifiedAddressing,                  :int,
+          :memoryClockRate,                    :int,
+          :memoryBusWidth,                     :int,
+          :l2CacheSize,                        :int,
+          :persistingL2CacheMaxSize,           :int,
+          :maxThreadsPerMultiProcessor,        :int,
+          :streamPrioritiesSupported,          :int,
+          :globalL1CacheSupported,             :int,
+          :localL1CacheSupported,              :int,
+          :sharedMemPerMultiprocessor,         :size_t,
+          :regsPerMultiprocessor,              :int,
+          :managedMemory,                      :int,
+          :isMultiGpuBoard,                    :int,
+          :multiGpuBoardGroupID,               :int,
+          :hostNativeAtomicSupported,          :int,
+          :singleToDoublePrecisionPerfRatio,   :int,
+          :pageableMemoryAccess,               :int,
+          :concurrentManagedAccess,            :int,
+          :computePreemptionSupported,         :int,
+          :canUseHostPointerForRegisteredMem,  :int,
+          :cooperativeLaunch,                  :int,
+          :cooperativeMultiDeviceLaunch,       :int,
+          :sharedMemPerBlockOptin,             :size_t,
+          :pageableMemoryAccessUsesHostPageTables, :int,
+          :directManagedMemAccessFromHost,     :int,
+          :maxBlocksPerMultiProcessor,         :int,
+          :accessPolicyMaxWindowSize,          :int,
+          :reservedSharedMemPerBlock,          :size_t,
+          :hostRegisterSupported,              :int,
+          :sparseCudaArraySupported,           :int,
+          :hostRegisterReadOnlySupported,      :int,
+          :timelineSemaphoreInteropSupported,  :int,
+          :memoryPoolsSupported,              :int,
+          :gpuDirectRDMASupported,            :int,
+          :gpuDirectRDMAFlushWritesOptions,   :uint,
+          :gpuDirectRDMAWritesOrdering,       :int,
+          :memoryPoolSupportedHandleTypes,    :uint,
+          :deferredMappingCudaArraySupported, :int,
+          :ipcEventSupported,                 :int,
+          :clusterLaunch,                     :int,
+          :unifiedFunctionPointers,           :int,
+          :_reserved_padding,                  [:char, 512]  # Padding for future fields
+      end
+
+      # Bind cudaGetDeviceProperties_v2
+      begin
+        attach_function :cudaGetDeviceProperties_v2, [:pointer, :int], :int
+      rescue FFI::NotFoundError
+        # Fall back to non-v2 variant
+        begin
+          attach_function :cudaGetDeviceProperties, [:pointer, :int], :int
+        rescue FFI::NotFoundError
+          $stderr.puts "[Ignis] WARNING: cudaGetDeviceProperties not found in #{CUDART_DLL}"
+        end
+      end
+
+      # Get device properties for a given device index.
+      #
+      # @param device_id [Integer] GPU device index
+      # @return [CudaDeviceProp]
+      # @raise [RuntimeError] if the CUDA call fails
+      def self.get(device_id)
+        prop = CudaDeviceProp.new
+
+        if respond_to?(:cudaGetDeviceProperties_v2)
+          status = cudaGetDeviceProperties_v2(prop.pointer, device_id)
+        elsif respond_to?(:cudaGetDeviceProperties)
+          status = cudaGetDeviceProperties(prop.pointer, device_id)
+        else
+          raise 'cudaGetDeviceProperties not available'
+        end
+
+        raise "cudaGetDeviceProperties failed with status #{status}" unless status.zero?
+
+        prop
+      end
+
+      # Helper to extract a human-readable property hash.
+      #
+      # @param device_id [Integer]
+      # @return [Hash]
+      def self.summary(device_id)
+        prop = get(device_id)
+        {
+          name: prop[:name].to_s.strip,
+          compute_capability: "#{prop[:major]}.#{prop[:minor]}",
+          total_memory_mb: (prop[:totalGlobalMem] / (1024.0 * 1024.0)).round(1),
+          multiprocessor_count: prop[:multiProcessorCount],
+          max_threads_per_block: prop[:maxThreadsPerBlock],
+          warp_size: prop[:warpSize],
+          memory_clock_mhz: prop[:memoryClockRate] / 1000,
+          memory_bus_width: prop[:memoryBusWidth],
+          l2_cache_kb: prop[:l2CacheSize] / 1024,
+          ecc_enabled: prop[:ECCEnabled] != 0,
+          unified_addressing: prop[:unifiedAddressing] != 0,
+          managed_memory: prop[:managedMemory] != 0,
+          cooperative_launch: prop[:cooperativeLaunch] != 0,
+          gpu_direct_rdma: prop[:gpuDirectRDMASupported] != 0,
+          memory_pools: prop[:memoryPoolsSupported] != 0,
+          cluster_launch: prop[:clusterLaunch] != 0
+        }
+      end
+    end
+  end
+end