ignis 0.0.1

data/lib/nvruby/cuda/runtime_api.rb

@@ -0,0 +1,804 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Ignis
+  module CUDA
+    # CUDA Runtime API — Fiddle-only hot-path bindings.
+    #
+    # Rule: This file uses ONLY Fiddle for hot-path calls (malloc, free, memcpy,
+    # stream, event, sync). FFI struct calls (cudaGetDeviceProperties) live in
+    # device_props.rb (Rule 4: never mix FFI and Fiddle in the same file).
+    #
+    # Cross-platform: Uses Ignis::Platform to resolve cudart path on Windows/Linux.
+    module RuntimeAPI
+      # CUDA memory copy directions
+      MEMCPY_HOST_TO_HOST = 0
+      MEMCPY_HOST_TO_DEVICE = 1
+      MEMCPY_DEVICE_TO_HOST = 2
+      MEMCPY_DEVICE_TO_DEVICE = 3
+      MEMCPY_DEFAULT = 4
+
+      # CUDA device flags
+      DEVICE_SCHEDULE_AUTO = 0
+      DEVICE_SCHEDULE_SPIN = 1
+      DEVICE_SCHEDULE_YIELD = 2
+      DEVICE_SCHEDULE_BLOCKING_SYNC = 4
+      DEVICE_MAP_HOST = 8
+      DEVICE_LMEM_RESIZE_TO_MAX = 16
+
+      # CUDA host alloc flags
+      HOST_ALLOC_DEFAULT = 0
+      HOST_ALLOC_PORTABLE = 1
+      HOST_ALLOC_MAPPED = 2
+      HOST_ALLOC_WRITECOMBINED = 4
+
+      # Resolve CUDA runtime library path at load time.
+      # Uses Ignis::Platform if available, falls back to OS detection.
+      CUDART_LIB = 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
+
+      @loaded = false
+      @handle = nil
+      @functions = {}
+
+      class << self
+        # @return [Fiddle::Handle, nil] the loaded DLL handle
+        attr_reader :handle
+
+        # Ensure the CUDA runtime is loaded and all functions are bound.
+        # @return [void]
+        # @raise [Fiddle::DLError] if the library cannot be loaded
+        def ensure_loaded!
+          return if @loaded
+
+          @handle = Fiddle::Handle.new(CUDART_LIB)
+          attach_all_functions!
+          @loaded = true
+        end
+
+        # @return [Boolean]
+        def loaded?
+          @loaded
+        end
+
+        # ================================================================
+        # Device Management
+        # ================================================================
+
+        # @return [Integer] number of CUDA devices
+        def get_device_count
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          status = @functions[:cudaGetDeviceCount].call(ptr)
+          check_status!(status, 'cudaGetDeviceCount')
+          ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+        end
+
+        # @return [Integer] current device index
+        def get_device
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          status = @functions[:cudaGetDevice].call(ptr)
+          check_status!(status, 'cudaGetDevice')
+          ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+        end
+
+        # @param device [Integer] device index to set
+        # @return [void]
+        def set_device(device)
+          ensure_loaded!
+          status = @functions[:cudaSetDevice].call(device)
+          check_status!(status, 'cudaSetDevice')
+        end
+
+        # @return [void]
+        def device_synchronize
+          ensure_loaded!
+          status = @functions[:cudaDeviceSynchronize].call
+          check_status!(status, 'cudaDeviceSynchronize')
+        end
+
+        # @return [void]
+        def device_reset
+          ensure_loaded!
+          status = @functions[:cudaDeviceReset].call
+          check_status!(status, 'cudaDeviceReset')
+        end
+
+        # @param attr_id [Integer] CUDA device attribute ID
+        # @param device [Integer] device index
+        # @return [Integer] attribute value
+        def device_get_attribute(attr_id, device)
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          status = @functions[:cudaDeviceGetAttribute].call(ptr, attr_id, device)
+          check_status!(status, 'cudaDeviceGetAttribute')
+          ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+        end
+
+        # ================================================================
+        # Memory Management (Hot Path)
+        # ================================================================
+
+        # Allocate device memory.
+        # @param size [Integer] bytes to allocate
+        # @return [Fiddle::Pointer] device pointer
+        def malloc(size)
+          ensure_loaded!
+          ptr_buf = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+          status = @functions[:cudaMalloc].call(ptr_buf, size)
+          check_status!(status, "cudaMalloc(#{size})")
+          Fiddle::Pointer.new(ptr_buf[0, Fiddle::SIZEOF_VOIDP].unpack1('Q'))
+        end
+
+        # Free device memory.
+        # @param ptr [Fiddle::Pointer] device pointer to free
+        # @return [void]
+        def free(ptr)
+          ensure_loaded!
+          status = @functions[:cudaFree].call(ptr)
+          check_status!(status, 'cudaFree')
+        end
+
+        # Copy memory.
+        # @param dst [Fiddle::Pointer] destination
+        # @param src [Fiddle::Pointer] source
+        # @param count [Integer] bytes to copy
+        # @param kind [Integer] copy direction constant
+        # @return [void]
+        def memcpy(dst, src, count, kind)
+          ensure_loaded!
+          status = @functions[:cudaMemcpy].call(dst, src, count, kind)
+          check_status!(status, "cudaMemcpy(#{count} bytes, kind=#{kind})")
+        end
+
+        # Async memory copy.
+        # @param dst [Fiddle::Pointer]
+        # @param src [Fiddle::Pointer]
+        # @param count [Integer]
+        # @param kind [Integer]
+        # @param stream [Fiddle::Pointer] CUDA stream
+        # @return [void]
+        def memcpy_async(dst, src, count, kind, stream)
+          ensure_loaded!
+          status = @functions[:cudaMemcpyAsync].call(dst, src, count, kind, stream)
+          check_status!(status, "cudaMemcpyAsync(#{count} bytes)")
+        end
+
+        # Set device memory.
+        # @param ptr [Fiddle::Pointer] device pointer
+        # @param value [Integer] byte value to set
+        # @param count [Integer] bytes to set
+        # @return [void]
+        def memset(ptr, value, count)
+          ensure_loaded!
+          status = @functions[:cudaMemset].call(ptr, value, count)
+          check_status!(status, "cudaMemset(#{count} bytes)")
+        end
+
+        # Allocate pinned host memory.
+        # @param size [Integer] bytes
+        # @param flags [Integer] allocation flags
+        # @return [Fiddle::Pointer] host pointer
+        def host_alloc(size, flags = HOST_ALLOC_DEFAULT)
+          ensure_loaded!
+          ptr_buf = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+          status = @functions[:cudaHostAlloc].call(ptr_buf, size, flags)
+          check_status!(status, "cudaHostAlloc(#{size})")
+          Fiddle::Pointer.new(ptr_buf[0, Fiddle::SIZEOF_VOIDP].unpack1('Q'))
+        end
+
+        # Free pinned host memory.
+        # @param ptr [Fiddle::Pointer]
+        # @return [void]
+        def free_host(ptr)
+          ensure_loaded!
+          status = @functions[:cudaFreeHost].call(ptr)
+          check_status!(status, 'cudaFreeHost')
+        end
+
+        # Query GPU memory info.
+        # @return [Hash] {free_bytes:, total_bytes:}
+        def mem_get_info
+          ensure_loaded!
+          free_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+          total_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+          status = @functions[:cudaMemGetInfo].call(free_ptr, total_ptr)
+          check_status!(status, 'cudaMemGetInfo')
+          {
+            free_bytes: free_ptr[0, Fiddle::SIZEOF_SIZE_T].unpack1('Q'),
+            total_bytes: total_ptr[0, Fiddle::SIZEOF_SIZE_T].unpack1('Q')
+          }
+        end
+
+        # ================================================================
+        # Stream-Ordered Memory (CUDA 11.2+)
+        # ================================================================
+
+        # @param size [Integer] bytes
+        # @param stream [Fiddle::Pointer] CUDA stream
+        # @return [Fiddle::Pointer] device pointer
+        def malloc_async(size, stream)
+          ensure_loaded!
+          ptr_buf = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+          status = @functions[:cudaMallocAsync].call(ptr_buf, size, stream)
+          check_status!(status, "cudaMallocAsync(#{size})")
+          Fiddle::Pointer.new(ptr_buf[0, Fiddle::SIZEOF_VOIDP].unpack1('Q'))
+        end
+
+        # @param ptr [Fiddle::Pointer] device pointer
+        # @param stream [Fiddle::Pointer] CUDA stream
+        # @return [void]
+        def free_async(ptr, stream)
+          ensure_loaded!
+          status = @functions[:cudaFreeAsync].call(ptr, stream)
+          check_status!(status, 'cudaFreeAsync')
+        end
+
+        # ================================================================
+        # Stream Management
+        # ================================================================
+
+        # Create a CUDA stream.
+        # @return [Fiddle::Pointer] stream handle
+        def stream_create
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+          status = @functions[:cudaStreamCreate].call(ptr)
+          check_status!(status, 'cudaStreamCreate')
+          Fiddle::Pointer.new(ptr[0, Fiddle::SIZEOF_VOIDP].unpack1('Q'))
+        end
+
+        # Destroy a CUDA stream.
+        # @param stream [Fiddle::Pointer]
+        # @return [void]
+        def stream_destroy(stream)
+          ensure_loaded!
+          status = @functions[:cudaStreamDestroy].call(stream)
+          check_status!(status, 'cudaStreamDestroy')
+        end
+
+        # Synchronize a stream (blocks until all commands complete).
+        # @param stream [Fiddle::Pointer]
+        # @return [void]
+        def stream_synchronize(stream)
+          ensure_loaded!
+          status = @functions[:cudaStreamSynchronize].call(stream)
+          check_status!(status, 'cudaStreamSynchronize')
+        end
+
+        # Query stream completion status.
+        # @param stream [Fiddle::Pointer]
+        # @return [Boolean] true if all work complete
+        def stream_query(stream)
+          ensure_loaded!
+          status = @functions[:cudaStreamQuery].call(stream)
+          status.zero?
+        end
+
+        # ================================================================
+        # Event Management
+        # ================================================================
+
+        # Create a CUDA event.
+        # @return [Fiddle::Pointer] event handle
+        def event_create
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+          status = @functions[:cudaEventCreate].call(ptr)
+          check_status!(status, 'cudaEventCreate')
+          Fiddle::Pointer.new(ptr[0, Fiddle::SIZEOF_VOIDP].unpack1('Q'))
+        end
+
+        # Destroy a CUDA event.
+        # @param event [Fiddle::Pointer]
+        # @return [void]
+        def event_destroy(event)
+          ensure_loaded!
+          status = @functions[:cudaEventDestroy].call(event)
+          check_status!(status, 'cudaEventDestroy')
+        end
+
+        # Record an event in a stream.
+        # @param event [Fiddle::Pointer]
+        # @param stream [Fiddle::Pointer]
+        # @return [void]
+        def event_record(event, stream)
+          ensure_loaded!
+          status = @functions[:cudaEventRecord].call(event, stream)
+          check_status!(status, 'cudaEventRecord')
+        end
+
+        # Block until event completes.
+        # @param event [Fiddle::Pointer]
+        # @return [void]
+        def event_synchronize(event)
+          ensure_loaded!
+          status = @functions[:cudaEventSynchronize].call(event)
+          check_status!(status, 'cudaEventSynchronize')
+        end
+
+        # Compute elapsed time between two events.
+        # @param start_event [Fiddle::Pointer]
+        # @param end_event [Fiddle::Pointer]
+        # @return [Float] elapsed time in milliseconds
+        def event_elapsed_time(start_event, end_event)
+          ensure_loaded!
+          ms_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_FLOAT)
+          status = @functions[:cudaEventElapsedTime].call(ms_ptr, start_event, end_event)
+          check_status!(status, 'cudaEventElapsedTime')
+          ms_ptr[0, Fiddle::SIZEOF_FLOAT].unpack1('e')
+        end
+
+        # ================================================================
+        # Error Handling
+        # ================================================================
+
+        # @return [Integer] last error code
+        def get_last_error
+          ensure_loaded!
+          @functions[:cudaGetLastError].call
+        end
+
+        # @return [Integer] last error without clearing
+        def peek_at_last_error
+          ensure_loaded!
+          @functions[:cudaPeekAtLastError].call
+        end
+
+        # Get error string for a status code.
+        # @param status [Integer]
+        # @return [String] error description
+        def get_error_string(status)
+          ensure_loaded!
+          ptr = @functions[:cudaGetErrorString].call(status)
+          Fiddle::Pointer.new(ptr).to_s
+        end
+
+        # Get error name for a status code.
+        # @param status [Integer]
+        # @return [String] error name
+        def get_error_name(status)
+          ensure_loaded!
+          ptr = @functions[:cudaGetErrorName].call(status)
+          Fiddle::Pointer.new(ptr).to_s
+        end
+
+        # ================================================================
+        # Version Info
+        # ================================================================
+
+        # @return [Integer] CUDA runtime version
+        def runtime_version
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          status = @functions[:cudaRuntimeGetVersion].call(ptr)
+          check_status!(status, 'cudaRuntimeGetVersion')
+          ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+        end
+
+        # @return [Integer] CUDA driver version
+        def driver_version
+          ensure_loaded!
+          ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+          status = @functions[:cudaDriverGetVersion].call(ptr)
+          check_status!(status, 'cudaDriverGetVersion')
+          ptr[0, Fiddle::SIZEOF_INT].unpack1('l')
+        end
+
+        # Check CUDA status and raise error if not success.
+        # @param status [Integer]
+        # @param context [String]
+        # @return [void]
+        # @raise [CudaRuntimeError]
+        def check_status!(status, context = 'CUDA operation')
+          return if status.zero?
+
+          ensure_loaded!
+          error_name = get_error_name(status)
+          error_string = get_error_string(status)
+          raise CudaRuntimeError.new(
+            "#{context}: #{error_name} - #{error_string}",
+            cuda_code: status
+          )
+        end
+
+        private
+
+        # Bind all CUDA runtime functions via Fiddle::Function.
+        # @return [void]
+        def attach_all_functions!
+          # Device management
+          bind(:cudaGetDeviceCount,    [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaGetDevice,         [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaSetDevice,         [Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaDeviceSynchronize, [], Fiddle::TYPE_INT)
+          bind(:cudaDeviceReset,       [], Fiddle::TYPE_INT)
+          bind(:cudaDeviceGetAttribute, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaGetDeviceProperties, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+
+          # Memory management (hot path)
+          bind(:cudaMalloc,     [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T], Fiddle::TYPE_INT)
+          bind(:cudaFree,       [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemcpy,     [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaMemcpyAsync, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemset,     [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_SIZE_T], Fiddle::TYPE_INT)
+          bind(:cudaMemsetAsync, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaHostAlloc,  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaFreeHost,   [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemGetInfo, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaHostRegister, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaHostUnregister, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMallocHost, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T], Fiddle::TYPE_INT)
+
+          # Stream-ordered memory
+          bind(:cudaMallocAsync,  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaFreeAsync,    [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMallocFromPoolAsync, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemPoolCreate, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemPoolDestroy, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemPoolSetAttribute, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaMemPoolGetAttribute, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaDeviceGetDefaultMemPool, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+          bind(:cudaDeviceSetMemPool, [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+
+          # Stream management
+          bind(:cudaStreamCreate,      [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaStreamDestroy,     [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaStreamSynchronize, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaStreamQuery,       [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+
+          # Event management
+          bind(:cudaEventCreate,      [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaEventDestroy,     [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaEventRecord,      [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaEventSynchronize, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaEventElapsedTime, [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+
+          # Error handling
+          bind(:cudaGetLastError,    [], Fiddle::TYPE_INT)
+          bind(:cudaPeekAtLastError, [], Fiddle::TYPE_INT)
+          bind(:cudaGetErrorString,  [Fiddle::TYPE_INT], Fiddle::TYPE_VOIDP)
+          bind(:cudaGetErrorName,    [Fiddle::TYPE_INT], Fiddle::TYPE_VOIDP)
+
+          # Version
+          bind(:cudaRuntimeGetVersion, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+          bind(:cudaDriverGetVersion,  [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+        end
+
+        # Bind a single CUDA runtime function via Fiddle.
+        # @param name [Symbol] function name
+        # @param arg_types [Array<Integer>] Fiddle type constants for arguments
+        # @param ret_type [Integer] Fiddle type constant for return
+        def bind(name, arg_types, ret_type)
+          @functions[name] = Fiddle::Function.new(
+            @handle[name.to_s],
+            arg_types,
+            ret_type
+          )
+        rescue Fiddle::DLError
+          $stderr.puts "[RuntimeAPI] WARNING: #{name} not found in #{CUDART_DLL}"
+        end
+
+        # ================================================================
+        # Backward-Compatible Shims
+        # ================================================================
+        # These methods maintain the old RuntimeAPI.cudaXxx call signatures
+        # so existing collective/transport code continues to work without
+        # modification. They delegate to the new Fiddle-based methods above.
+        # The raw Fiddle function is available for callers that need status
+        # codes instead of exceptions.
+
+        public
+
+        # @!group Backward-Compatible Shims
+
+        # Raw CUDA function calls returning status codes (for legacy callers).
+        # These call the underlying Fiddle::Function directly.
+
+        # @param device_id [Integer]
+        # @return [Integer] CUDA status code
+        def cudaSetDevice(device_id)
+          ensure_loaded!
+          @functions[:cudaSetDevice].call(device_id)
+        end
+
+        # @return [Integer] status
+        def cudaDeviceSynchronize
+          ensure_loaded!
+          @functions[:cudaDeviceSynchronize].call
+        end
+
+        # @return [Integer] status
+        def cudaDeviceReset
+          ensure_loaded!
+          @functions[:cudaDeviceReset].call
+        end
+
+        # @param ptr_out [Fiddle::Pointer, FFI::Pointer] pointer-to-pointer
+        # @return [Integer] status
+        def cudaGetDeviceCount(ptr_out)
+          ensure_loaded!
+          @functions[:cudaGetDeviceCount].call(ptr_out)
+        end
+
+        # @param ptr_out [Fiddle::Pointer, FFI::Pointer] pointer-to-int
+        # @return [Integer] status
+        def cudaGetDevice(ptr_out)
+          ensure_loaded!
+          @functions[:cudaGetDevice].call(ptr_out)
+        end
+
+        # @param ptr_out [Fiddle::Pointer] pointer-to-int
+        # @param attr_id [Integer]
+        # @param device [Integer]
+        # @return [Integer] status
+        def cudaDeviceGetAttribute(ptr_out, attr_id, device)
+          ensure_loaded!
+          @functions[:cudaDeviceGetAttribute].call(ptr_out, attr_id, device)
+        end
+
+        # @param ptr_ptr [Fiddle::Pointer] pointer-to-pointer
+        # @param size [Integer]
+        # @return [Integer] status
+        def cudaMalloc(ptr_ptr, size)
+          ensure_loaded!
+          @functions[:cudaMalloc].call(ptr_ptr, size)
+        end
+
+        # @param ptr [Fiddle::Pointer]
+        # @return [Integer] status
+        def cudaFree(ptr)
+          ensure_loaded!
+          @functions[:cudaFree].call(ptr)
+        end
+
+        # @return [Integer] status
+        def cudaMemcpy(dst, src, count, kind)
+          ensure_loaded!
+          kind_int = resolve_memcpy_kind(kind)
+          @functions[:cudaMemcpy].call(dst, src, count, kind_int)
+        end
+
+        # @return [Integer] status
+        def cudaMemcpyAsync(dst, src, count, kind, stream)
+          ensure_loaded!
+          kind_int = resolve_memcpy_kind(kind)
+          @functions[:cudaMemcpyAsync].call(dst, src, count, kind_int, stream)
+        end
+
+        # @return [Integer] status
+        def cudaMemset(ptr, value, count)
+          ensure_loaded!
+          @functions[:cudaMemset].call(ptr, value, count)
+        end
+
+        # @return [Integer] status
+        def cudaMemsetAsync(ptr, value, count, stream)
+          ensure_loaded!
+          @functions[:cudaMemsetAsync].call(ptr, value, count, stream)
+        end
+
+        # @return [Integer] status
+        def cudaMemGetInfo(free_ptr, total_ptr)
+          ensure_loaded!
+          @functions[:cudaMemGetInfo].call(free_ptr, total_ptr)
+        end
+
+        # @param ptr_ptr [Fiddle::Pointer] pointer-to-pointer
+        # @param size [Integer]
+        # @param flags [Integer]
+        # @return [Integer] status
+        def cudaHostAlloc(ptr_ptr, size, flags)
+          ensure_loaded!
+          @functions[:cudaHostAlloc].call(ptr_ptr, size, flags)
+        end
+
+        # @param ptr [Fiddle::Pointer]
+        # @return [Integer] status
+        def cudaFreeHost(ptr)
+          ensure_loaded!
+          @functions[:cudaFreeHost].call(ptr)
+        end
+
+        # @return [Integer] status
+        def cudaStreamCreate(ptr_out)
+          ensure_loaded!
+          @functions[:cudaStreamCreate].call(ptr_out)
+        end
+
+        # @return [Integer] status
+        def cudaStreamDestroy(stream)
+          ensure_loaded!
+          @functions[:cudaStreamDestroy].call(stream)
+        end
+
+        # @return [Integer] status
+        def cudaStreamSynchronize(stream)
+          ensure_loaded!
+          @functions[:cudaStreamSynchronize].call(stream)
+        end
+
+        # @return [Integer] status
+        def cudaEventCreate(ptr_out)
+          ensure_loaded!
+          @functions[:cudaEventCreate].call(ptr_out)
+        end
+
+        # @return [Integer] status
+        def cudaEventDestroy(event)
+          ensure_loaded!
+          @functions[:cudaEventDestroy].call(event)
+        end
+
+        # @return [Integer] status
+        def cudaEventRecord(event, stream)
+          ensure_loaded!
+          @functions[:cudaEventRecord].call(event, stream)
+        end
+
+        # @return [Integer] status
+        def cudaEventSynchronize(event)
+          ensure_loaded!
+          @functions[:cudaEventSynchronize].call(event)
+        end
+
+        # @return [Integer] status
+        def cudaEventElapsedTime(ms_ptr, start_event, end_event)
+          ensure_loaded!
+          @functions[:cudaEventElapsedTime].call(ms_ptr, start_event, end_event)
+        end
+
+        # @return [Integer] status
+        def cudaGetLastError
+          ensure_loaded!
+          @functions[:cudaGetLastError].call
+        end
+
+        # @return [Integer] status
+        def cudaPeekAtLastError
+          ensure_loaded!
+          @functions[:cudaPeekAtLastError].call
+        end
+
+        # @param status [Integer]
+        # @return [String]
+        def cudaGetErrorString(status)
+          get_error_string(status)
+        end
+
+        # @param status [Integer]
+        # @return [String]
+        def cudaGetErrorName(status)
+          get_error_name(status)
+        end
+
+        # @param ptr [Fiddle::Pointer] host pointer to register
+        # @param size [Integer] bytes
+        # @param flags [Integer]
+        # @return [Integer] status
+        def cudaHostRegister(ptr, size, flags)
+          ensure_loaded!
+          @functions[:cudaHostRegister]&.call(ptr, size, flags) || 0
+        end
+
+        # @param ptr [Fiddle::Pointer] host pointer to unregister
+        # @return [Integer] status
+        def cudaHostUnregister(ptr)
+          ensure_loaded!
+          @functions[:cudaHostUnregister]&.call(ptr) || 0
+        end
+
+        # @param ptr [Fiddle::Pointer] pointer-to-pointer
+        # @param size [Integer]
+        # @return [Integer] status
+        def cudaMallocHost(ptr_ptr, size)
+          ensure_loaded!
+          @functions[:cudaMallocHost]&.call(ptr_ptr, size) || cudaHostAlloc(ptr_ptr, size, 0)
+        end
+
+        # @param ptr_out [Fiddle::Pointer]
+        # @param size [Integer]
+        # @param stream [Fiddle::Pointer]
+        # @return [Integer] status
+        def cudaMallocAsync(ptr_out, size, stream)
+          ensure_loaded!
+          @functions[:cudaMallocAsync].call(ptr_out, size, stream)
+        end
+
+        # @param ptr [Fiddle::Pointer]
+        # @param stream [Fiddle::Pointer]
+        # @return [Integer] status
+        def cudaFreeAsync(ptr, stream)
+          ensure_loaded!
+          @functions[:cudaFreeAsync].call(ptr, stream)
+        end
+
+        # @param ptr_out [Fiddle::Pointer] pointer to store version
+        # @return [Integer] status
+        def cudaRuntimeGetVersion(ptr_out)
+          ensure_loaded!
+          @functions[:cudaRuntimeGetVersion].call(ptr_out)
+        end
+
+        # @return [Integer] status
+        def cudaMemPoolDestroy(pool)
+          ensure_loaded!
+          @functions[:cudaMemPoolDestroy]&.call(pool) || 0
+        end
+
+        # @return [Integer] status
+        def cudaMallocFromPoolAsync(ptr_ptr, size, pool, stream)
+          ensure_loaded!
+          @functions[:cudaMallocFromPoolAsync]&.call(ptr_ptr, size, pool, stream) || 0
+        end
+
+        # @return [Integer] status
+        def cudaDeviceGetDefaultMemPool(pool_ptr, device)
+          ensure_loaded!
+          @functions[:cudaDeviceGetDefaultMemPool]&.call(pool_ptr, device) || 0
+        end
+
+        # @return [Integer] status
+        def cudaMemPoolSetAttribute(pool, attr, value_ptr)
+          ensure_loaded!
+          @functions[:cudaMemPoolSetAttribute]&.call(pool, attr, value_ptr) || 0
+        end
+
+        # @return [Integer] status
+        def cudaMemPoolGetAttribute(pool, attr, value_ptr)
+          ensure_loaded!
+          @functions[:cudaMemPoolGetAttribute]&.call(pool, attr, value_ptr) || 0
+        end
+
+        # @return [Integer] status
+        def cudaDeviceSetMemPool(device, pool)
+          ensure_loaded!
+          @functions[:cudaDeviceSetMemPool]&.call(device, pool) || 0
+        end
+
+        # @return [Integer] status
+        def cudaMemPoolCreate(pool_ptr, props)
+          ensure_loaded!
+          @functions[:cudaMemPoolCreate]&.call(pool_ptr, props) || 0
+        end
+
+        # @return [Integer] status
+        def cudaGetDeviceProperties(prop_ptr, device)
+          ensure_loaded!
+          @functions[:cudaGetDeviceProperties]&.call(prop_ptr, device) || 0
+        end
+
+        # @!endgroup
+
+        private
+
+        # Resolve symbolic or integer memcpy kind.
+        # @param kind [Symbol, Integer]
+        # @return [Integer]
+        def resolve_memcpy_kind(kind)
+          case kind
+          when Integer then kind
+          when :host_to_host then MEMCPY_HOST_TO_HOST
+          when :host_to_device then MEMCPY_HOST_TO_DEVICE
+          when :device_to_host then MEMCPY_DEVICE_TO_HOST
+          when :device_to_device then MEMCPY_DEVICE_TO_DEVICE
+          when :default then MEMCPY_DEFAULT
+          else kind.to_i
+          end
+        end
+      end
+
+      # Also bind cudaHostRegister / cudaHostUnregister in attach_all_functions!
+      # This is handled by adding to the bind list
+    end
+  end
+end