ignis-collective 0.0.1

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "socket"
+
+module Ignis
+  module Collective
+    module Transport
+      # TCP Fallback Transport
+      # Generic TCP transport for multi-node communication
+      # Used when higher-performance transports are unavailable
+      #
+      # @note This is the lowest-performance multi-node option
+      #       but works on any network configuration
+      #
+      # @example Create TCP transport
+      #   transport = TCPTransport.new(
+      #     local_addr: "192.168.1.100",
+      #     local_port: 50000,
+      #     remote_addr: "192.168.1.101",
+      #     remote_port: 50000,
+      #     mode: :client  # or :server
+      #   )
+      #
+      class TCPTransport < Base
+        # Default buffer size for staging
+        DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024  # 16 MB
+
+        # Connection timeout in seconds
+        CONNECT_TIMEOUT = 30
+
+        # @return [String] Local address
+        attr_reader :local_addr
+
+        # @return [Integer] Local port
+        attr_reader :local_port
+
+        # @return [String] Remote address
+        attr_reader :remote_addr
+
+        # @return [Integer] Remote port
+        attr_reader :remote_port
+
+        # @return [Symbol] Mode (:client or :server)
+        attr_reader :mode
+
+        # @return [Symbol] Transport type
+        def self.transport_type
+          :tcp
+        end
+
+        # @param local_addr [String] Local IP address
+        # @param local_port [Integer] Local port
+        # @param remote_addr [String] Remote IP address
+        # @param remote_port [Integer] Remote port
+        # @param mode [Symbol] :client or :server
+        # @param buffer_size [Integer] Staging buffer size
+        def initialize(local_addr:, local_port:, remote_addr:, remote_port:,
+                       mode: :client, buffer_size: DEFAULT_BUFFER_SIZE)
+          super(src_device: 0, dst_device: 0)
+          @local_addr = local_addr
+          @local_port = local_port
+          @remote_addr = remote_addr
+          @remote_port = remote_port
+          @mode = mode
+          @buffer_size = buffer_size
+          @socket = nil
+          @server_socket = nil
+          @send_buffer = nil
+          @recv_buffer = nil
+          @initialized = false
+          @mutex = Mutex.new
+        end
+
+        # Initialize TCP transport
+        # @return [void]
+        def initialize!
+          return if @initialized
+
+          allocate_buffers!
+
+          if @mode == :server
+            start_server!
+          else
+            connect_to_server!
+          end
+
+          @initialized = true
+        end
+
+        # Check if ready
+        # @return [Boolean]
+        def ready?
+          @initialized && @socket && !@socket.closed?
+        end
+
+        # Send data to remote
+        #
+        # @param src_ptr [FFI::Pointer] Source GPU buffer pointer
+        # @param size [Integer] Size in bytes
+        # @param stream [FFI::Pointer, nil] CUDA stream
+        # @return [Boolean] Success
+        def send(src_ptr, size, stream: nil)
+          ensure_initialized!
+          # Guard against overflowing the fixed-size host staging buffer:
+          # stage_to_host copies `size` bytes into the @buffer_size buffer, so a
+          # larger transfer corrupts the heap. Chunked staging for >buffer_size
+          # transfers isn't implemented yet — fail loudly instead of overflowing.
+          if size > @buffer_size
+            raise TransportError,
+                  "TCP transfer of #{size} bytes exceeds the #{@buffer_size}-byte host staging " \
+                  "buffer (chunked staging not implemented); increase buffer_size or chunk the transfer"
+          end
+          @mutex.synchronize do
+            # Stage GPU data to host buffer
+            stage_to_host(src_ptr, size, stream)
+
+            # Send size header
+            send_header(size)
+
+            # Send data in chunks
+            bytes_sent = 0
+            while bytes_sent < size
+              chunk_size = [size - bytes_sent, @buffer_size].min
+              sent = @socket.send(@send_buffer.get_bytes(bytes_sent, chunk_size), 0)
+              raise TransportError, "TCP send failed" if sent <= 0
+
+              bytes_sent += sent
+            end
+
+            true
+          end
+        end
+
+        # Receive data from remote
+        #
+        # @param dst_ptr [FFI::Pointer] Destination GPU buffer pointer
+        # @param size [Integer] Expected size in bytes
+        # @param stream [FFI::Pointer, nil] CUDA stream
+        # @return [Integer] Bytes received
+        def recv(dst_ptr, size, stream: nil)
+          ensure_initialized!
+          @mutex.synchronize do
+            # Receive size header
+            actual_size = recv_header
+
+            # The header size comes from the peer; a malformed/hostile peer could
+            # announce a size larger than the staging buffer, and put_bytes below
+            # would then write past it (heap overflow). Bound it.
+            if actual_size > @buffer_size
+              raise TransportError,
+                    "TCP recv header announces #{actual_size} bytes, exceeding the " \
+                    "#{@buffer_size}-byte staging buffer (refusing to overflow)"
+            end
+
+            # Receive data in chunks
+            bytes_received = 0
+            while bytes_received < actual_size
+              chunk_size = [actual_size - bytes_received, @buffer_size].min
+              data = @socket.recv(chunk_size)
+              raise TransportError, "TCP recv failed" if data.nil? || data.empty?
+
+              @recv_buffer.put_bytes(bytes_received, data)
+              bytes_received += data.bytesize
+            end
+
+            # Copy from host buffer to GPU
+            unstage_from_host(dst_ptr, actual_size, stream)
+
+            actual_size
+          end
+        end
+
+        # Estimated bandwidth in GB/s
+        # @return [Float]
+        def estimated_bandwidth
+          1.25  # ~10 Gbps typical for TCP
+        end
+
+        # Clean up resources
+        # @return [void]
+        def destroy!
+          return unless @initialized
+
+          @socket&.close
+          @server_socket&.close
+          free_buffers!
+
+          @socket = nil
+          @server_socket = nil
+          @initialized = false
+        end
+
+        # @return [String]
+        def to_s
+          status = ready? ? "connected" : "disconnected"
+          "TCPTransport[#{@local_addr}:#{@local_port} <-> #{@remote_addr}:#{@remote_port}, #{status}]"
+        end
+
+        private
+
+        def ensure_initialized!
+          raise TransportError, "TCP transport not initialized" unless @initialized
+        end
+
+        def allocate_buffers!
+          # Allocate pinned host memory for GPU staging
+          @send_buffer = FFI::MemoryPointer.new(:char, @buffer_size)
+          @recv_buffer = FFI::MemoryPointer.new(:char, @buffer_size)
+
+          # Pin for faster GPU transfers
+          CUDA::RuntimeAPI.cudaHostRegister(@send_buffer, @buffer_size, 0)
+          CUDA::RuntimeAPI.cudaHostRegister(@recv_buffer, @buffer_size, 0)
+        rescue StandardError => e
+          Ignis.logger.warn { "Failed to pin TCP buffers: #{e.message}" }
+        end
+
+        def free_buffers!
+          CUDA::RuntimeAPI.cudaHostUnregister(@send_buffer) if @send_buffer
+          CUDA::RuntimeAPI.cudaHostUnregister(@recv_buffer) if @recv_buffer
+        rescue StandardError
+          # Ignore unregister errors during cleanup
+        end
+
+        def start_server!
+          @server_socket = TCPServer.new(@local_addr, @local_port)
+          @server_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+          @server_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+
+          Ignis.logger.info { "TCP transport listening on #{@local_addr}:#{@local_port}" }
+
+          # Accept connection with timeout
+          ready = IO.select([@server_socket], nil, nil, CONNECT_TIMEOUT)
+          raise TransportError, "Timeout waiting for connection" unless ready
+
+          @socket = @server_socket.accept
+          configure_socket!
+
+          Ignis.logger.info { "TCP transport accepted connection from #{@socket.peeraddr[2]}" }
+        end
+
+        def connect_to_server!
+          @socket = TCPSocket.new(@remote_addr, @remote_port)
+          configure_socket!
+
+          Ignis.logger.info { "TCP transport connected to #{@remote_addr}:#{@remote_port}" }
+        rescue Errno::ECONNREFUSED => e
+          raise TransportError, "Connection refused: #{e.message}"
+        rescue Errno::ETIMEDOUT => e
+          raise TransportError, "Connection timeout: #{e.message}"
+        end
+
+        def configure_socket!
+          @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+          @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, @buffer_size)
+          @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, @buffer_size)
+        end
+
+        def stage_to_host(src_ptr, size, stream)
+          if stream
+            CUDA::RuntimeAPI.cudaMemcpyAsync(@send_buffer, src_ptr, size, :device_to_host, stream)
+            CUDA::RuntimeAPI.cudaStreamSynchronize(stream)
+          else
+            CUDA::RuntimeAPI.cudaMemcpy(@send_buffer, src_ptr, size, :device_to_host)
+          end
+        end
+
+        def unstage_from_host(dst_ptr, size, stream)
+          if stream
+            CUDA::RuntimeAPI.cudaMemcpyAsync(dst_ptr, @recv_buffer, size, :host_to_device, stream)
+          else
+            CUDA::RuntimeAPI.cudaMemcpy(dst_ptr, @recv_buffer, size, :host_to_device)
+          end
+        end
+
+        def send_header(size)
+          header = [size].pack("Q<")  # 64-bit little-endian
+          @socket.send(header, 0)
+        end
+
+        def recv_header
+          header = @socket.recv(8)
+          raise TransportError, "Failed to receive header" if header.nil? || header.bytesize < 8
+
+          header.unpack1("Q<")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# VMM IPC Structs — FFI::Struct definitions for CUDA Virtual Memory Management
+#
+# Rule 4: FFI structs live in their own file, never mixed with Fiddle hot-path calls.
+# These structs are used by the VMM IPC transport for multi-GPU memory sharing.
+
+require "ignis"
+Ignis::Shared::FFILoader.load!
+
+module Ignis
+  module Collective
+    module Transport
+      # FFI struct definitions for CUDA VMM (Virtual Memory Management) IPC.
+      module VmmIpcStructs
+        extend FFI::Library
+
+        # Resolve CUDA driver library per platform.
+        CUDA_DRIVER_LIB = if defined?(Ignis::Platform)
+                            Ignis::Platform.find_cuda_lib(:cuda_driver) || (Ignis::Platform.windows? ? 'nvcuda.dll' : 'libcuda.so.1')
+                          elsif RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+                            cuda_bin = File.join('C:', 'Program Files', 'NVIDIA GPU Computing Toolkit', 'CUDA', 'v13.0', 'bin')
+                            File.join(cuda_bin, 'nvcuda.dll')
+                          else
+                            'libcuda.so.1'
+                          end
+
+        begin
+          ffi_lib CUDA_DRIVER_LIB
+        rescue LoadError => e
+          $stderr.puts "[NvCCL] WARNING: Cannot load #{CUDA_DRIVER_LIB}: #{e.message}"
+        end
+
+        # CUmemLocationType — specifies where memory is located
+        CU_MEM_LOCATION_TYPE_INVALID = 0
+        CU_MEM_LOCATION_TYPE_DEVICE  = 1
+        CU_MEM_LOCATION_TYPE_HOST    = 2
+
+        # CUmemAllocationType
+        CU_MEM_ALLOCATION_TYPE_INVALID = 0
+        CU_MEM_ALLOCATION_TYPE_PINNED  = 1
+
+        # CUmemAccess_flags
+        CU_MEM_ACCESS_FLAGS_PROT_NONE      = 0
+        CU_MEM_ACCESS_FLAGS_PROT_READ      = 1
+        CU_MEM_ACCESS_FLAGS_PROT_READWRITE = 3
+
+        # CUmemAllocationHandleType
+        CU_MEM_HANDLE_TYPE_NONE             = 0
+        CU_MEM_HANDLE_TYPE_POSIX_FILE_DESC  = 1
+        CU_MEM_HANDLE_TYPE_WIN32            = 2
+        CU_MEM_HANDLE_TYPE_WIN32_KMT        = 4
+        CU_MEM_HANDLE_TYPE_FABRIC           = 8
+
+        # CUmemLocation — memory location descriptor
+        class CUmemLocation < FFI::Struct
+          layout \
+            :type,   :int,    # CUmemLocationType
+            :id,     :int     # Device ordinal (for DEVICE type)
+        end
+
+        # CUmemAccessDesc — memory access descriptor
+        class CUmemAccessDesc < FFI::Struct
+          layout \
+            :location, CUmemLocation,
+            :flags,    :uint    # CUmemAccess_flags
+        end
+
+        # CUmemAllocationProp — memory allocation properties
+        class CUmemAllocationProp < FFI::Struct
+          layout \
+            :type,                :int,       # CUmemAllocationType
+            :requestedHandleTypes, :int,      # CUmemAllocationHandleType bitmask
+            :location,            CUmemLocation,
+            :win32HandleMetaData, :pointer,   # Windows security descriptor (NULL for default)
+            :allocFlags_compressionType, :uchar,
+            :allocFlags_gpuDirectRDMACapable, :uchar,
+            :allocFlags_usage, :ushort,
+            :_reserved, [:uchar, 4]
+        end
+
+        # CUmemGenericAllocationHandle — opaque handle
+        # This is a uint64 (CUmemGenericAllocationHandle) on all platforms.
+        # We use :uint64 since FFI doesn't have an opaque handle type.
+
+        # IPC memory handle for sharing across processes
+        class CUipcMemHandle < FFI::Struct
+          layout :reserved, [:char, 64]
+        end
+
+        # IPC event handle
+        class CUipcEventHandle < FFI::Struct
+          layout :reserved, [:char, 64]
+        end
+
+        # Helper: Create a CUmemLocation for a given GPU device.
+        # @param device_id [Integer]
+        # @return [CUmemLocation]
+        def self.device_location(device_id)
+          loc = CUmemLocation.new
+          loc[:type] = CU_MEM_LOCATION_TYPE_DEVICE
+          loc[:id] = device_id
+          loc
+        end
+
+        # Helper: Create a CUmemAccessDesc for read-write access to a device.
+        # @param device_id [Integer]
+        # @return [CUmemAccessDesc]
+        def self.device_rw_access(device_id)
+          desc = CUmemAccessDesc.new
+          desc[:location][:type] = CU_MEM_LOCATION_TYPE_DEVICE
+          desc[:location][:id] = device_id
+          desc[:flags] = CU_MEM_ACCESS_FLAGS_PROT_READWRITE
+          desc
+        end
+
+        # Helper: Create CUmemAllocationProp for device-pinned memory
+        # with Windows handle support (Win32).
+        #
+        # @param device_id [Integer]
+        # @param rdma_capable [Boolean] whether to request GPU Direct RDMA
+        # @return [CUmemAllocationProp]
+        def self.pinned_device_prop(device_id, rdma_capable: false)
+          prop = CUmemAllocationProp.new
+          prop[:type] = CU_MEM_ALLOCATION_TYPE_PINNED
+          prop[:requestedHandleTypes] = if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+                                           CU_MEM_HANDLE_TYPE_WIN32
+                                         else
+                                           CU_MEM_HANDLE_TYPE_POSIX_FILE_DESC
+                                         end
+          prop[:location][:type] = CU_MEM_LOCATION_TYPE_DEVICE
+          prop[:location][:id] = device_id
+          prop[:win32HandleMetaData] = FFI::Pointer::NULL
+          prop[:allocFlags_compressionType] = 0
+          prop[:allocFlags_gpuDirectRDMACapable] = rdma_capable ? 1 : 0
+          prop[:allocFlags_usage] = 0
+          prop
+        end
+
+        # Bind VMM functions if DLL is available
+        begin
+          # cuMemAddressReserve(CUdeviceptr *ptr, size_t size, size_t alignment, CUdeviceptr addr, unsigned long long flags)
+          attach_function :cuMemAddressReserve, [:pointer, :size_t, :size_t, :uint64, :uint64], :int
+
+          # cuMemAddressFree(CUdeviceptr ptr, size_t size)
+          attach_function :cuMemAddressFree, [:uint64, :size_t], :int
+
+          # cuMemCreate(CUmemGenericAllocationHandle *handle, size_t size, const CUmemAllocationProp *prop, unsigned long long flags)
+          attach_function :cuMemCreate, [:pointer, :size_t, :pointer, :uint64], :int
+
+          # cuMemRelease(CUmemGenericAllocationHandle handle)
+          attach_function :cuMemRelease, [:uint64], :int
+
+          # cuMemMap(CUdeviceptr ptr, size_t size, size_t offset, CUmemGenericAllocationHandle handle, unsigned long long flags)
+          attach_function :cuMemMap, [:uint64, :size_t, :size_t, :uint64, :uint64], :int
+
+          # cuMemUnmap(CUdeviceptr ptr, size_t size)
+          attach_function :cuMemUnmap, [:uint64, :size_t], :int
+
+          # cuMemSetAccess(CUdeviceptr ptr, size_t size, const CUmemAccessDesc *desc, size_t count)
+          attach_function :cuMemSetAccess, [:uint64, :size_t, :pointer, :size_t], :int
+
+          # cuMemGetAllocationGranularity(size_t *granularity, const CUmemAllocationProp *prop, CUmemAllocationGranularity_flags option)
+          attach_function :cuMemGetAllocationGranularity, [:pointer, :pointer, :int], :int
+
+          # IPC functions
+          attach_function :cuIpcGetMemHandle, [:pointer, :uint64], :int
+          attach_function :cuIpcOpenMemHandle, [:pointer, CUipcMemHandle.by_value, :uint], :int
+          attach_function :cuIpcCloseMemHandle, [:uint64], :int
+
+          attach_function :cuIpcGetEventHandle, [:pointer, :uint64], :int
+          attach_function :cuIpcOpenEventHandle, [:pointer, CUipcEventHandle.by_value], :int
+
+          VMM_AVAILABLE = true
+        rescue FFI::NotFoundError => e
+          $stderr.puts "[NvCCL] VMM functions not available: #{e.message}"
+          VMM_AVAILABLE = false
+        rescue StandardError
+          VMM_AVAILABLE = false
+        end
+
+        # @return [Boolean]
+        def self.available?
+          defined?(VMM_AVAILABLE) && VMM_AVAILABLE
+        end
+      end
+    end
+  end
+end