ignis-collective 0.0.1

data/lib/nvruby/collective/transport/vmm_ipc_transport.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../vmm_bindings"
+
+module Ignis
+  module Collective
+    module Transport
+      # VMM IPC Transport - Modern CUDA Virtual Memory Management IPC
+      # 
+      # Uses cuMemExportToShareableHandle with CU_MEM_HANDLE_TYPE_WIN32 for
+      # cross-process GPU memory sharing on Windows. Required for sharing
+      # memory allocated with cudaMallocAsync.
+      #
+      # Workflow:
+      # 1. Sender: cuMemCreate -> cuMemExportToShareableHandle -> send HANDLE
+      # 2. Receiver: cuMemImportFromShareableHandle -> cuMemAddressReserve -> cuMemMap -> cuMemSetAccess
+      class VMMIPCTransport < Base
+        # @return [Symbol] Transport type identifier
+        def self.transport_type
+          :vmm_ipc
+        end
+
+        # @return [Float] Estimated bandwidth (GB/s)
+        def estimated_bandwidth
+          25.0  # PCIe-limited with IPC overhead
+        end
+
+        # @return [Float] Estimated latency (microseconds)
+        def estimated_latency
+          10.0  # IPC overhead higher than P2P
+        end
+
+        # Initialize the transport
+        # @return [void]
+        def initialize!
+          return if @initialized
+
+          VMMBindings.ensure_loaded!
+          @exported_handles = {}    # device_ptr -> {handle: CUmemGenericAllocationHandle, win32_handle: HANDLE}
+          @imported_handles = {}    # win32_handle -> {alloc_handle, va_ptr, size}
+          @initialized = true
+        end
+
+        # Create a VMM allocation on source device (shareable)
+        # @param size [Integer] Size in bytes
+        # @return [Hash] {:device_ptr, :alloc_handle, :win32_handle}
+        def create_shareable_allocation(size)
+          ensure_initialized!
+
+          # Get allocation granularity
+          prop = VMMBindings.create_allocation_prop(device_id: @src_device, shareable: true)
+          granularity_ptr = FFI::MemoryPointer.new(:size_t)
+          
+          status = VMMBindings.cuMemGetAllocationGranularity(
+            granularity_ptr,
+            prop,
+            0  # CU_MEM_ALLOC_GRANULARITY_MINIMUM
+          )
+          VMMBindings.check_status!(status, "Get allocation granularity")
+
+          granularity = granularity_ptr.read_size_t
+          aligned_size = ((size + granularity - 1) / granularity) * granularity
+
+          # Create allocation
+          handle_ptr = FFI::MemoryPointer.new(:uint64)
+          status = VMMBindings.cuMemCreate(handle_ptr, aligned_size, prop, 0)
+          VMMBindings.check_status!(status, "VMM cuMemCreate")
+
+          alloc_handle = handle_ptr.read_uint64
+
+          # Reserve virtual address
+          va_ptr_ptr = FFI::MemoryPointer.new(:uint64)
+          status = VMMBindings.cuMemAddressReserve(va_ptr_ptr, aligned_size, 0, 0, 0)
+          VMMBindings.check_status!(status, "VMM cuMemAddressReserve")
+
+          va_ptr = va_ptr_ptr.read_uint64
+
+          # Map allocation to virtual address
+          status = VMMBindings.cuMemMap(va_ptr, aligned_size, 0, alloc_handle, 0)
+          VMMBindings.check_status!(status, "VMM cuMemMap")
+
+          # Set access for source device
+          access_desc = VMMBindings.create_access_desc(device_id: @src_device, read_write: true)
+          status = VMMBindings.cuMemSetAccess(va_ptr, aligned_size, access_desc, 1)
+          VMMBindings.check_status!(status, "VMM cuMemSetAccess")
+
+          # Export to Windows HANDLE
+          win32_handle_ptr = FFI::MemoryPointer.new(:pointer)
+          status = VMMBindings.cuMemExportToShareableHandle(
+            win32_handle_ptr,
+            alloc_handle,
+            VMMBindings::CU_MEM_HANDLE_TYPE_WIN32,
+            0
+          )
+          VMMBindings.check_status!(status, "VMM cuMemExportToShareableHandle")
+
+          win32_handle = win32_handle_ptr.read_pointer
+
+          # Cache for cleanup
+          @exported_handles[va_ptr] = {
+            alloc_handle: alloc_handle,
+            win32_handle: win32_handle,
+            size: aligned_size
+          }
+
+          {
+            device_ptr: FFI::Pointer.new(:uint8, va_ptr),
+            alloc_handle: alloc_handle,
+            win32_handle: win32_handle,
+            size: aligned_size
+          }
+        end
+
+        # Import a shareable allocation on destination device
+        # @param win32_handle [FFI::Pointer] Windows HANDLE from sender
+        # @param size [Integer] Size in bytes
+        # @return [FFI::Pointer] Device pointer mapped on destination GPU
+        def import_shareable_allocation(win32_handle, size)
+          ensure_initialized!
+
+          # Import the handle
+          handle_ptr = FFI::MemoryPointer.new(:uint64)
+          status = VMMBindings.cuMemImportFromShareableHandle(
+            handle_ptr,
+            win32_handle,
+            VMMBindings::CU_MEM_HANDLE_TYPE_WIN32
+          )
+          VMMBindings.check_status!(status, "VMM cuMemImportFromShareableHandle")
+
+          alloc_handle = handle_ptr.read_uint64
+
+          # Get granularity for alignment
+          prop_ptr = VMMBindings::CUmemAllocationProp.new
+          status = VMMBindings.cuMemGetAllocationPropertiesFromHandle(prop_ptr, alloc_handle)
+          VMMBindings.check_status!(status, "Get allocation properties")
+
+          # Reserve virtual address on destination device
+          va_ptr_ptr = FFI::MemoryPointer.new(:uint64)
+          status = VMMBindings.cuMemAddressReserve(va_ptr_ptr, size, 0, 0, 0)
+          VMMBindings.check_status!(status, "VMM cuMemAddressReserve (import)")
+
+          va_ptr = va_ptr_ptr.read_uint64
+
+          # Map
+          status = VMMBindings.cuMemMap(va_ptr, size, 0, alloc_handle, 0)
+          VMMBindings.check_status!(status, "VMM cuMemMap (import)")
+
+          # Set access for destination device
+          access_desc = VMMBindings.create_access_desc(device_id: @dst_device, read_write: true)
+          status = VMMBindings.cuMemSetAccess(va_ptr, size, access_desc, 1)
+          VMMBindings.check_status!(status, "VMM cuMemSetAccess (import)")
+
+          # Cache for cleanup
+          @imported_handles[win32_handle.address] = {
+            alloc_handle: alloc_handle,
+            va_ptr: va_ptr,
+            size: size
+          }
+
+          FFI::Pointer.new(:uint8, va_ptr)
+        end
+
+        # Close an imported handle
+        # @param device_ptr [FFI::Pointer] The mapped device pointer
+        # @return [void]
+        def close_imported_handle(device_ptr)
+          va_ptr = device_ptr.address
+          
+          # Find the imported handle info
+          @imported_handles.each do |handle_addr, info|
+            next unless info[:va_ptr] == va_ptr
+
+            # Unmap
+            VMMBindings.cuMemUnmap(va_ptr, info[:size])
+            
+            # Free address
+            VMMBindings.cuMemAddressFree(va_ptr, info[:size])
+            
+            # Release handle
+            VMMBindings.cuMemRelease(info[:alloc_handle])
+
+            @imported_handles.delete(handle_addr)
+            break
+          end
+        end
+
+        # Copy data via VMM IPC (used when both sender and receiver have mapped)
+        # @param dst_buffer [FFI::Pointer] Destination (on dst_device)
+        # @param src_buffer [FFI::Pointer] Source (on src_device)
+        # @param size [Integer] Size in bytes
+        # @param stream [FFI::Pointer] CUDA stream
+        def copy_async(dst_buffer, src_buffer, size, stream)
+          ensure_initialized!
+
+          # For VMM IPC, once both sides have mapped the same allocation,
+          # we can use regular cudaMemcpyAsync
+          CUDA::RuntimeAPI.ensure_loaded!
+          
+          status = CUDA::RuntimeAPI.cudaMemcpyAsync(
+            dst_buffer,
+            src_buffer,
+            size,
+            CUDA::RuntimeAPI::MEMCPY_DEVICE_TO_DEVICE,
+            stream
+          )
+          CUDA::RuntimeAPI.check_status!(status, "VMM IPC copy")
+        end
+
+        # Async send (export and copy)
+        # @param buffer [FFI::Pointer] Source buffer
+        # @param size [Integer] Size in bytes
+        # @param stream [FFI::Pointer] CUDA stream
+        # @return [Hash] {:win32_handle, :size} for receiver
+        def send_async(buffer, size, stream)
+          # For VMM IPC, we typically create a shareable allocation first
+          # This method assumes buffer is already a VMM allocation
+          raise NotImplementedError, "Use create_shareable_allocation and copy_async"
+        end
+
+        # Async receive
+        # @param buffer [FFI::Pointer] Destination buffer
+        # @param size [Integer] Size
+        # @param stream [FFI::Pointer] CUDA stream
+        # @return [void]
+        def recv_async(buffer, size, stream)
+          raise NotImplementedError, "Use import_shareable_allocation and copy_async"
+        end
+
+        # Check if VMM IPC is available
+        # @return [Boolean] True if available
+        def self.available?
+          begin
+            VMMBindings.ensure_loaded!
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+        # Clean up all handles
+        # @return [void]
+        def destroy!
+          # Cleanup exported handles
+          @exported_handles.each do |va_ptr, info|
+            VMMBindings.cuMemUnmap(va_ptr, info[:size]) rescue nil
+            VMMBindings.cuMemAddressFree(va_ptr, info[:size]) rescue nil
+            VMMBindings.cuMemRelease(info[:alloc_handle]) rescue nil
+            # Note: win32_handle should be closed by caller
+          end
+          @exported_handles.clear
+
+          # Cleanup imported handles
+          @imported_handles.each do |_, info|
+            VMMBindings.cuMemUnmap(info[:va_ptr], info[:size]) rescue nil
+            VMMBindings.cuMemAddressFree(info[:va_ptr], info[:size]) rescue nil
+            VMMBindings.cuMemRelease(info[:alloc_handle]) rescue nil
+          end
+          @imported_handles.clear
+
+          @initialized = false
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/collective/transport_selector.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "topology"
+require_relative "transport/base"
+require_relative "transport/p2p_transport"
+require_relative "transport/ipc_transport"
+
+module Ignis
+  module Collective
+    # Automatic transport selector - NCCL-style
+    # Detects topology at init time and selects optimal transport for each GPU pair
+    class TransportSelector
+      # Transport types ranked by performance (highest first)
+      TRANSPORT_PRIORITY = [
+        :nvlink,          # NVLink - 900 GB/s
+        :pcie_p2p,        # PCIe P2P - 32 GB/s
+        :cuda_vmm_ipc,    # cuMem VMM IPC - 25 GB/s
+        :cuda_ipc,        # Legacy CUDA IPC - 20 GB/s
+        :host_staged,     # Host staging - 12 GB/s
+        :rio_network,     # Windows RIO - 100 Gbps
+        :tcp,             # TCP fallback - variable
+      ].freeze
+
+      # Map interconnect types to transport classes
+      TRANSPORT_CLASSES = {
+        nvlink: Transport::P2PTransport,
+        pcie_p2p: Transport::P2PTransport,
+        cuda_ipc: Transport::IPCTransport,
+        cuda_vmm_ipc: Transport::IPCTransport,
+        host_staged: nil,  # TODO: Implement SHMTransport
+        rio_network: nil,  # TODO: Implement RIOTransport
+        tcp: nil,          # TODO: Implement TCPTransport
+      }.freeze
+
+      # @return [Array<Integer>] GPU device IDs in this communicator
+      attr_reader :device_ids
+
+      # @return [Topology::Detector] Topology detector
+      attr_reader :topology
+
+      # @return [Hash<Array<Integer>, Transport::Base>] Transport matrix
+      attr_reader :transport_matrix
+
+      # Create transport selector for given GPUs
+      # @param device_ids [Array<Integer>] GPU device IDs
+      def initialize(device_ids)
+        @device_ids = device_ids.dup.freeze
+        @topology = Topology::Detector.new(device_ids: @device_ids)
+        @transport_matrix = {}
+        @initialized = false
+      end
+
+      # Initialize all transports
+      # @return [void]
+      def initialize!
+        return if @initialized
+
+        build_transport_matrix!
+        initialize_transports!
+        @initialized = true
+      end
+
+      # Get optimal transport for a GPU pair
+      # @param src [Integer] Source GPU
+      # @param dst [Integer] Destination GPU
+      # @return [Transport::Base, nil] Best transport or nil if same GPU
+      def select_transport(src, dst)
+        return nil if src == dst
+
+        @transport_matrix[[src, dst]]
+      end
+
+      # Get transport type for a GPU pair
+      # @param src [Integer] Source GPU
+      # @param dst [Integer] Destination GPU
+      # @return [Symbol, nil] Transport type
+      def transport_type(src, dst)
+        transport = select_transport(src, dst)
+        transport&.class&.transport_type
+      end
+
+      # Get optimal ring order based on topology
+      # @return [Array<Integer>] Ordered GPU IDs for ring algorithm
+      def optimal_ring_order
+        @topology.optimal_ring_order
+      end
+
+      # Check if all transports are ready
+      # @return [Boolean] True if initialized
+      def ready?
+        @initialized && @transport_matrix.values.all?(&:ready?)
+      end
+
+      # Get performance summary for logging
+      # @return [Hash] Performance stats
+      def performance_summary
+        nvlink_count = 0
+        p2p_count = 0
+        ipc_count = 0
+        staged_count = 0
+
+        @transport_matrix.each_value do |transport|
+          case transport
+          when Transport::P2PTransport
+            if transport.interconnect_type == :nvlink
+              nvlink_count += 1
+            else
+              p2p_count += 1
+            end
+          when Transport::IPCTransport
+            ipc_count += 1
+          else
+            staged_count += 1
+          end
+        end
+
+        total = @device_ids.size * (@device_ids.size - 1)
+        avg_bandwidth = @transport_matrix.values.sum(&:estimated_bandwidth) / [@transport_matrix.size, 1].max
+
+        {
+          total_paths: total,
+          nvlink_paths: nvlink_count,
+          p2p_paths: p2p_count,
+          ipc_paths: ipc_count,
+          staged_paths: staged_count,
+          avg_bandwidth_gbps: avg_bandwidth.round(1),
+        }
+      end
+
+      # Clean up all transports
+      # @return [void]
+      def destroy!
+        @transport_matrix.each_value(&:destroy!)
+        @transport_matrix.clear
+        @initialized = false
+      end
+
+      # @return [String] Human-readable summary
+      def to_s
+        stats = performance_summary
+        "TransportSelector[#{@device_ids.size} GPUs]: " \
+          "#{stats[:nvlink_paths]} NVLink, #{stats[:p2p_paths]} P2P, " \
+          "#{stats[:ipc_paths]} IPC (avg #{stats[:avg_bandwidth_gbps]} GB/s)"
+      end
+
+      private
+
+      # Build transport matrix based on detected topology
+      def build_transport_matrix!
+        @device_ids.each do |src|
+          @device_ids.each do |dst|
+            next if src == dst
+
+            @transport_matrix[[src, dst]] = create_transport(src, dst)
+          end
+        end
+      end
+
+      # Create appropriate transport for a GPU pair
+      # @param src [Integer] Source GPU
+      # @param dst [Integer] Destination GPU
+      # @return [Transport::Base] Transport instance
+      def create_transport(src, dst)
+        path = @topology.matrix.path(src, dst)
+        interconnect = path&.interconnect_type || :host_staged
+
+        case interconnect
+        when :nvlink
+          Transport::P2PTransport.new(
+            src_device: src,
+            dst_device: dst,
+            interconnect_type: :nvlink
+          )
+        when :pcie_p2p
+          Transport::P2PTransport.new(
+            src_device: src,
+            dst_device: dst,
+            interconnect_type: :pcie_p2p
+          )
+        when :cuda_ipc, :cuda_vmm_ipc
+          Transport::IPCTransport.new(
+            src_device: src,
+            dst_device: dst
+          )
+        else
+          # Fallback to IPC which always works
+          Transport::IPCTransport.new(
+            src_device: src,
+            dst_device: dst
+          )
+        end
+      end
+
+      # Initialize all transports
+      def initialize_transports!
+        @transport_matrix.each_value(&:initialize!)
+      end
+    end
+  end
+end

data/lib/nvruby/collective/vmm_bindings.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module Collective
+    # cuMem VMM (Virtual Memory Management) API bindings for modern IPC
+    # Required for sharing cudaMallocAsync allocations on Windows
+    # Uses cuMemExportToShareableHandle with CU_MEM_HANDLE_TYPE_WIN32
+    module VMMBindings
+      extend FFI::Library
+
+      # Handle types for shareable handles
+      CU_MEM_HANDLE_TYPE_NONE = 0
+      CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = 1
+      CU_MEM_HANDLE_TYPE_WIN32 = 2
+      CU_MEM_HANDLE_TYPE_WIN32_KMT = 4
+
+      # Memory allocation types
+      CU_MEM_ALLOCATION_TYPE_INVALID = 0
+      CU_MEM_ALLOCATION_TYPE_PINNED = 1  # Pinned memory, can be shared
+      CU_MEM_ALLOCATION_TYPE_MAX = 0xFFFFFFFF
+
+      # Allocation location types
+      CU_MEM_LOCATION_TYPE_INVALID = 0
+      CU_MEM_LOCATION_TYPE_DEVICE = 1
+      CU_MEM_LOCATION_TYPE_HOST = 2
+      CU_MEM_LOCATION_TYPE_HOST_NUMA = 3
+      CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT = 4
+      CU_MEM_LOCATION_TYPE_MAX = 0xFFFFFFFF
+
+      # Memory access flags
+      CU_MEM_ACCESS_FLAGS_PROT_NONE = 0
+      CU_MEM_ACCESS_FLAGS_PROT_READ = 1
+      CU_MEM_ACCESS_FLAGS_PROT_READWRITE = 3
+
+      # CUmemLocation structure
+      class CUmemLocation < FFI::Struct
+        layout :type, :int,       # CU_MEM_LOCATION_TYPE_*
+               :id, :int          # Device ordinal for DEVICE type
+      end
+
+      # CUmemAllocationProp structure for cuMemCreate
+      class CUmemAllocationProp < FFI::Struct
+        layout :type, :int,                       # CU_MEM_ALLOCATION_TYPE_*
+               :requestedHandleTypes, :int,       # OR of CU_MEM_HANDLE_TYPE_*
+               :location, CUmemLocation,          # Memory location
+               :win32HandleMetaData, :pointer,    # LPSECURITY_ATTRIBUTES for Win32
+               :allocFlags, :uint16,              # Reserved flags
+               :reserved, [:uint8, 14]            # Padding
+      end
+
+      # CUmemAccessDesc structure for cuMemSetAccess
+      class CUmemAccessDesc < FFI::Struct
+        layout :location, CUmemLocation,   # Target device/host
+               :flags, :int                # CU_MEM_ACCESS_FLAGS_*
+      end
+
+      # CUmemGenericAllocationHandle (unsigned long long)
+      typedef :uint64, :CUmemGenericAllocationHandle
+
+      # Load CUDA driver library (platform-aware)
+      def self.ensure_loaded!
+        return if @loaded
+
+        begin
+          driver_lib = if defined?(Ignis::Platform)
+                         Ignis::Platform.find_cuda_lib(:cuda_driver) || (Ignis::Platform.windows? ? 'nvcuda' : 'libcuda')
+                       else
+                         RUBY_PLATFORM =~ /mswin|mingw|cygwin/ ? 'nvcuda' : 'libcuda'
+                       end
+          ffi_lib [driver_lib, "nvcuda", "libcuda"]
+          attach_vmm_functions!
+          @loaded = true
+        rescue FFI::NotFoundError => e
+          raise LoadError, "Could not load CUDA driver library: #{e.message}"
+        end
+      end
+
+      def self.attach_vmm_functions!
+        # Memory allocation via VMM
+        attach_function :cuMemCreate, [
+          :pointer,                    # CUmemGenericAllocationHandle* handle
+          :size_t,                     # size
+          :pointer,                    # const CUmemAllocationProp* prop
+          :uint64                      # flags (must be 0)
+        ], :int
+
+        # Get allocation size granularity
+        attach_function :cuMemGetAllocationGranularity, [
+          :pointer,                    # size_t* granularity
+          :pointer,                    # const CUmemAllocationProp* prop
+          :int                         # CUmemAllocationGranularity_flags
+        ], :int
+
+        # Release allocation handle
+        attach_function :cuMemRelease, [
+          :uint64                      # CUmemGenericAllocationHandle handle
+        ], :int
+
+        # Export to shareable handle (Windows HANDLE or POSIX fd)
+        attach_function :cuMemExportToShareableHandle, [
+          :pointer,                    # void* shareableHandle (HANDLE* or int*)
+          :uint64,                     # CUmemGenericAllocationHandle handle
+          :int,                        # CUmemAllocationHandleType handleType
+          :uint64                      # flags (must be 0)
+        ], :int
+
+        # Import from shareable handle
+        attach_function :cuMemImportFromShareableHandle, [
+          :pointer,                    # CUmemGenericAllocationHandle* handle
+          :pointer,                    # void* osHandle (HANDLE or int)
+          :int                         # CUmemAllocationHandleType handleType
+        ], :int
+
+        # Reserve virtual address range
+        attach_function :cuMemAddressReserve, [
+          :pointer,                    # CUdeviceptr* ptr
+          :size_t,                     # size
+          :size_t,                     # alignment (0 = default)
+          :uint64,                     # addr (0 = any)
+          :uint64                      # flags (must be 0)
+        ], :int
+
+        # Free reserved address range
+        attach_function :cuMemAddressFree, [
+          :uint64,                     # CUdeviceptr ptr
+          :size_t                      # size
+        ], :int
+
+        # Map allocation to address range
+        attach_function :cuMemMap, [
+          :uint64,                     # CUdeviceptr ptr
+          :size_t,                     # size
+          :size_t,                     # offset
+          :uint64,                     # CUmemGenericAllocationHandle handle
+          :uint64                      # flags (must be 0)
+        ], :int
+
+        # Unmap allocation
+        attach_function :cuMemUnmap, [
+          :uint64,                     # CUdeviceptr ptr
+          :size_t                      # size
+        ], :int
+
+        # Set memory access for specific devices
+        attach_function :cuMemSetAccess, [
+          :uint64,                     # CUdeviceptr ptr
+          :size_t,                     # size
+          :pointer,                    # const CUmemAccessDesc* desc
+          :size_t                      # count (number of descriptors)
+        ], :int
+
+        # Get allocation properties
+        attach_function :cuMemGetAllocationPropertiesFromHandle, [
+          :pointer,                    # CUmemAllocationProp* prop
+          :uint64                      # CUmemGenericAllocationHandle handle
+        ], :int
+      end
+
+      # Check status and raise on error
+      # @param status [Integer] CUDA driver error code
+      # @param context [String] Operation description
+      def self.check_status!(status, context = "VMM operation")
+        return if status.zero?  # CUDA_SUCCESS
+
+        # NOTE: previously this called cuGetErrorName, which is never attached in
+        # this module — so on ANY driver error it raised NoMethodError, masking the
+        # real failure. Report the numeric driver code directly instead.
+        raise CudaRuntimeError.new("#{context}: CUDA driver error #{status}", cuda_code: status)
+      end
+
+      # Helper: create allocation properties for device memory
+      # @param device_id [Integer] Target GPU device
+      # @param shareable [Boolean] Whether to allow IPC sharing
+      # @return [CUmemAllocationProp] Allocation properties
+      def self.create_allocation_prop(device_id:, shareable: true)
+        prop = CUmemAllocationProp.new
+        prop[:type] = CU_MEM_ALLOCATION_TYPE_PINNED
+
+        if shareable
+          handle_type = if defined?(Ignis::Platform)
+                          Ignis::Platform.windows? ? CU_MEM_HANDLE_TYPE_WIN32 : CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
+                        else
+                          RUBY_PLATFORM =~ /mswin|mingw|cygwin/ ? CU_MEM_HANDLE_TYPE_WIN32 : CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
+                        end
+          prop[:requestedHandleTypes] = handle_type
+        else
+          prop[:requestedHandleTypes] = 0
+        end
+
+        prop[:location][:type] = CU_MEM_LOCATION_TYPE_DEVICE
+        prop[:location][:id] = device_id
+        prop[:win32HandleMetaData] = FFI::Pointer::NULL
+        prop[:allocFlags] = 0
+        prop
+      end
+
+      # Helper: create access descriptor for device
+      # @param device_id [Integer] Target device
+      # @param read_write [Boolean] Read-write access?
+      # @return [CUmemAccessDesc] Access descriptor
+      def self.create_access_desc(device_id:, read_write: true)
+        desc = CUmemAccessDesc.new
+        desc[:location][:type] = CU_MEM_LOCATION_TYPE_DEVICE
+        desc[:location][:id] = device_id
+        desc[:flags] = read_write ? CU_MEM_ACCESS_FLAGS_PROT_READWRITE : CU_MEM_ACCESS_FLAGS_PROT_READ
+        desc
+      end
+    end
+  end
+end