ignis-collective 0.0.1

data/lib/nvruby/collective/net/nd_adapter.rb

@@ -0,0 +1,450 @@
+# frozen_string_literal: true
+
+require_relative "nd_bindings"
+
+module Ignis
+  module Collective
+    module NetworkDirect
+      # RDMA Adapter wrapper for NetworkDirect
+      #
+      # Represents a single RDMA-capable NIC (e.g., Mellanox ConnectX-5)
+      # and provides methods for creating queue pairs and memory regions.
+      class Adapter
+        # @return [String] Adapter identifier
+        attr_reader :adapter_id
+
+        # @return [FFI::Pointer] Native adapter handle
+        attr_reader :handle
+
+        # @return [Bindings::ND2AdapterInfo] Adapter capabilities
+        attr_reader :info
+
+        # Initialize adapter wrapper
+        # @param handle [FFI::Pointer] Native IND2Adapter handle
+        # @param adapter_id [String] Adapter identifier
+        def initialize(handle, adapter_id)
+          @handle = handle
+          @adapter_id = adapter_id
+          @info = nil
+          @completion_queues = []
+          @queue_pairs = []
+          @memory_regions = []
+        end
+
+        # Query adapter capabilities
+        # @return [Hash] Adapter capabilities
+        def query
+          return @capabilities if @capabilities
+
+          @info = Bindings::ND2AdapterInfo.new
+          # In real implementation, call IND2Adapter::Query via COM interop
+
+          @capabilities = {
+            vendor_id: @info[:VendorId],
+            device_id: @info[:DeviceId],
+            max_registration_size: @info[:MaxRegistrationSize],
+            max_sge_count: @info[:MaxSgeCount],
+            max_send_queue_depth: @info[:MaxSendQueueDepth],
+            max_recv_queue_depth: @info[:MaxRecvQueueDepth],
+            max_cq_depth: @info[:MaxCqDepth],
+            max_inline_data: @info[:MaxInlineData],
+            max_outbound_read_limit: @info[:MaxOutboundReadLimit],
+            max_inbound_read_limit: @info[:MaxInboundReadLimit]
+          }
+        end
+
+        # Create a completion queue
+        # @param depth [Integer] Number of entries
+        # @return [CompletionQueue] New completion queue
+        def create_completion_queue(depth: 256)
+          cq = CompletionQueue.new(self, depth)
+          cq.create!
+          @completion_queues << cq
+          cq
+        end
+
+        # Create a queue pair
+        # @param send_cq [CompletionQueue] Send completion queue
+        # @param recv_cq [CompletionQueue] Receive completion queue
+        # @param send_depth [Integer] Send queue depth
+        # @param recv_depth [Integer] Receive queue depth
+        # @param sge_count [Integer] Max SGE per work request
+        # @return [QueuePair] New queue pair
+        def create_queue_pair(send_cq:, recv_cq:, send_depth: 64, recv_depth: 64, sge_count: 1)
+          qp = QueuePair.new(
+            adapter: self,
+            send_cq: send_cq,
+            recv_cq: recv_cq,
+            send_depth: send_depth,
+            recv_depth: recv_depth,
+            sge_count: sge_count
+          )
+          qp.create!
+          @queue_pairs << qp
+          qp
+        end
+
+        # Register a memory region for RDMA
+        # @param buffer [FFI::Pointer] Buffer to register
+        # @param size [Integer] Buffer size
+        # @param flags [Integer] Registration flags
+        # @return [MemoryRegion] Registered memory region
+        def register_memory(buffer, size, flags: 0)
+          mr = MemoryRegion.new(self, buffer, size, flags)
+          mr.register!
+          @memory_regions << mr
+          mr
+        end
+
+        # Create a connector for connection establishment
+        # @return [Connector] New connector
+        def create_connector
+          Connector.new(self)
+        end
+
+        # Release all resources
+        # @return [void]
+        def close!
+          @queue_pairs.each(&:close!)
+          @completion_queues.each(&:close!)
+          @memory_regions.each(&:deregister!)
+
+          @queue_pairs.clear
+          @completion_queues.clear
+          @memory_regions.clear
+
+          # Release native handle
+          # In real implementation: IND2Adapter::Release
+          @handle = nil
+        end
+      end
+
+      # Completion Queue for RDMA operation completions
+      class CompletionQueue
+        # @return [Adapter] Parent adapter
+        attr_reader :adapter
+
+        # @return [Integer] Queue depth
+        attr_reader :depth
+
+        # @return [FFI::Pointer] Native CQ handle
+        attr_reader :handle
+
+        def initialize(adapter, depth)
+          @adapter = adapter
+          @depth = depth
+          @handle = nil
+          @created = false
+        end
+
+        # Create the completion queue
+        # @return [void]
+        def create!
+          return if @created
+
+          # In real implementation: IND2Adapter::CreateCompletionQueue
+          @handle = FFI::Pointer.new(:void, 0x12345678)  # Placeholder
+          @created = true
+        end
+
+        # Poll for completions
+        # @param max_results [Integer] Max completions to retrieve
+        # @return [Array<Hash>] Completion results
+        def poll(max_results: 16)
+          return [] unless @created
+
+          # Allocate result buffer
+          results_ptr = FFI::MemoryPointer.new(Bindings::ND2Result, max_results)
+          count_ptr = FFI::MemoryPointer.new(:uint32)
+
+          # In real implementation: IND2CompletionQueue::GetResults
+          # Returns array of completion results
+
+          # Parse results
+          results = []
+          count = count_ptr.read_uint32
+          count.times do |i|
+            result = Bindings::ND2Result.new(results_ptr + i * Bindings::ND2Result.size)
+            results << {
+              status: result[:Status],
+              bytes_transferred: result[:BytesTransferred],
+              context: result[:RequestContext],
+              type: result[:RequestType]
+            }
+          end
+
+          results
+        end
+
+        # Wait for completion with timeout
+        # @param timeout_ms [Integer] Timeout in milliseconds
+        # @return [Boolean] True if completion available
+        def wait(timeout_ms: 1000)
+          return false unless @created
+
+          # In real implementation: IND2CompletionQueue::Notify with INFINITE or timeout
+          true
+        end
+
+        # Close the completion queue
+        # @return [void]
+        def close!
+          return unless @created
+
+          # In real implementation: IND2CompletionQueue::Release
+          @handle = nil
+          @created = false
+        end
+      end
+
+      # Queue Pair for RDMA send/receive operations
+      class QueuePair
+        # States
+        STATE_INIT = :init
+        STATE_READY = :ready
+        STATE_CONNECTED = :connected
+        STATE_ERROR = :error
+
+        # @return [Adapter] Parent adapter
+        attr_reader :adapter
+
+        # @return [Symbol] Current state
+        attr_reader :state
+
+        # @return [FFI::Pointer] Native QP handle
+        attr_reader :handle
+
+        def initialize(adapter:, send_cq:, recv_cq:, send_depth:, recv_depth:, sge_count:)
+          @adapter = adapter
+          @send_cq = send_cq
+          @recv_cq = recv_cq
+          @send_depth = send_depth
+          @recv_depth = recv_depth
+          @sge_count = sge_count
+          @handle = nil
+          @state = STATE_INIT
+        end
+
+        # Create the queue pair
+        # @return [void]
+        def create!
+          return if @state != STATE_INIT
+
+          # In real implementation: IND2Adapter::CreateQueuePair
+          @handle = FFI::Pointer.new(:void, 0x87654321)  # Placeholder
+          @state = STATE_READY
+        end
+
+        # Post a send work request
+        # @param sge_list [Array<Hash>] Scatter-gather entries
+        # @param context [FFI::Pointer] User context
+        # @param flags [Integer] Send flags (inline, signaled, etc.)
+        # @return [void]
+        def post_send(sge_list:, context: nil, flags: 0)
+          raise RDMAError, "QP not ready" unless @state == STATE_CONNECTED
+
+          # Build SGE array
+          sge_count = sge_list.size
+          sge_ptr = FFI::MemoryPointer.new(Bindings::ND2Sge, sge_count)
+
+          sge_list.each_with_index do |sge, i|
+            entry = Bindings::ND2Sge.new(sge_ptr + i * Bindings::ND2Sge.size)
+            entry[:Buffer] = sge[:buffer]
+            entry[:BufferLength] = sge[:length]
+            entry[:MemoryRegionToken] = sge[:token]
+          end
+
+          # In real implementation: IND2QueuePair::Send
+        end
+
+        # Post a receive work request
+        # @param sge_list [Array<Hash>] Scatter-gather entries
+        # @param context [FFI::Pointer] User context
+        # @return [void]
+        def post_receive(sge_list:, context: nil)
+          raise RDMAError, "QP not ready" unless @state == STATE_READY || @state == STATE_CONNECTED
+
+          # Build SGE array (similar to post_send)
+          # In real implementation: IND2QueuePair::Receive
+        end
+
+        # RDMA Write operation (one-sided)
+        # @param remote_address [Integer] Remote buffer address
+        # @param remote_token [Integer] Remote memory token
+        # @param sge_list [Array<Hash>] Local scatter-gather entries
+        # @param context [FFI::Pointer] User context
+        # @return [void]
+        def rdma_write(remote_address:, remote_token:, sge_list:, context: nil)
+          raise RDMAError, "QP not connected" unless @state == STATE_CONNECTED
+
+          # In real implementation: IND2QueuePair::Write
+        end
+
+        # RDMA Read operation (one-sided)
+        # @param remote_address [Integer] Remote buffer address
+        # @param remote_token [Integer] Remote memory token
+        # @param sge_list [Array<Hash>] Local scatter-gather entries
+        # @param context [FFI::Pointer] User context
+        # @return [void]
+        def rdma_read(remote_address:, remote_token:, sge_list:, context: nil)
+          raise RDMAError, "QP not connected" unless @state == STATE_CONNECTED
+
+          # In real implementation: IND2QueuePair::Read
+        end
+
+        # Transition to connected state
+        # @return [void]
+        def set_connected!
+          @state = STATE_CONNECTED
+        end
+
+        # Close the queue pair
+        # @return [void]
+        def close!
+          # In real implementation: IND2QueuePair::Release
+          @handle = nil
+          @state = STATE_ERROR
+        end
+      end
+
+      # Memory Region for RDMA registration
+      class MemoryRegion
+        # @return [FFI::Pointer] Buffer pointer
+        attr_reader :buffer
+
+        # @return [Integer] Buffer size
+        attr_reader :size
+
+        # @return [Integer] Memory region token (for remote access)
+        attr_reader :token
+
+        # @return [FFI::Pointer] Native MR handle
+        attr_reader :handle
+
+        def initialize(adapter, buffer, size, flags)
+          @adapter = adapter
+          @buffer = buffer
+          @size = size
+          @flags = flags
+          @handle = nil
+          @token = nil
+          @registered = false
+        end
+
+        # Register the memory region
+        # @return [void]
+        def register!
+          return if @registered
+
+          # In real implementation: IND2Adapter::CreateMemoryRegion + Register
+          @handle = FFI::Pointer.new(:void, 0xABCDEF00)  # Placeholder
+          @token = rand(0xFFFFFFFF)  # Would be from GetRemoteToken
+          @registered = true
+        end
+
+        # Get remote access token for RDMA write/read
+        # @return [Hash] Remote access info
+        def remote_access_info
+          raise RDMAError, "Memory not registered" unless @registered
+
+          {
+            address: @buffer.address,
+            token: @token,
+            size: @size
+          }
+        end
+
+        # Deregister the memory region
+        # @return [void]
+        def deregister!
+          return unless @registered
+
+          # In real implementation: IND2MemoryRegion::Deregister + Release
+          @handle = nil
+          @token = nil
+          @registered = false
+        end
+      end
+
+      # Connector for RDMA connection establishment
+      class Connector
+        # @return [Adapter] Parent adapter
+        attr_reader :adapter
+
+        # @return [FFI::Pointer] Native connector handle
+        attr_reader :handle
+
+        def initialize(adapter)
+          @adapter = adapter
+          @handle = nil
+          @bound = false
+          @connected = false
+        end
+
+        # Bind to local address
+        # @param address [String] Local IP address
+        # @param port [Integer] Local port
+        # @return [void]
+        def bind(address:, port:)
+          return if @bound
+
+          # In real implementation: IND2Connector::Bind
+          @local_address = address
+          @local_port = port
+          @bound = true
+        end
+
+        # Connect to remote peer (client side)
+        # @param qp [QueuePair] Queue pair to connect
+        # @param remote_address [String] Remote IP address
+        # @param remote_port [Integer] Remote port
+        # @param private_data [String, nil] Connection private data
+        # @return [void]
+        def connect(qp:, remote_address:, remote_port:, private_data: nil)
+          raise RDMAError, "Not bound" unless @bound
+
+          # In real implementation: IND2Connector::Connect
+          # Then poll for completion
+          # Then CompleteConnect
+
+          @connected = true
+          qp.set_connected!
+        end
+
+        # Accept connection (server side)
+        # @param qp [QueuePair] Queue pair for the connection
+        # @param private_data [String, nil] Response private data
+        # @return [void]
+        def accept(qp:, private_data: nil)
+          raise RDMAError, "Not bound" unless @bound
+
+          # In real implementation:
+          # 1. Listen for incoming connection
+          # 2. GetConnectionRequest
+          # 3. Accept with QP
+
+          @connected = true
+          qp.set_connected!
+        end
+
+        # Disconnect
+        # @return [void]
+        def disconnect!
+          return unless @connected
+
+          # In real implementation: IND2Connector::Disconnect
+          @connected = false
+        end
+
+        # Close the connector
+        # @return [void]
+        def close!
+          disconnect! if @connected
+          # Release handle
+          @handle = nil
+          @bound = false
+        end
+      end
+    end
+  end
+end

data/lib/nvruby/collective/net/nd_bindings.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Ignis
+  module Collective
+    module NetworkDirect
+      # Windows NetworkDirect SPI v2 FFI Bindings
+      #
+      # NetworkDirect is **Windows-native** RDMA API supporting:
+      # - InfiniBand
+      # - RoCE (RDMA over Converged Ethernet)
+      # - iWARP
+      #
+      # Requires: Mellanox ConnectX NICs with WinOF-2 drivers
+      #
+      # Key interfaces (COM-based):
+      # - IND2Provider: Service provider, opens adapters
+      # - IND2Adapter: Hardware adapter, creates queues
+      # - IND2CompletionQueue: RDMA completion notifications
+      # - IND2QueuePair: Send/Receive queue pair for I/O
+      # - IND2MemoryRegion: Registered RDMA memory
+      # - IND2Connector: Connection establishment
+      module Bindings
+        extend FFI::Library
+
+        # NetworkDirect status codes
+        ND_SUCCESS = 0
+        ND_TIMEOUT = 0x80070102
+        ND_PENDING = 0x80000005
+        ND_BUFFER_OVERFLOW = 0x8007006F
+        ND_DEVICE_NOT_READY = 0x80070015
+        ND_NO_MEMORY = 0x8007000E
+        ND_CONNECTION_REFUSED = 0x8007107D
+        ND_CONNECTION_ABORTED = 0x80070453
+        ND_CONNECTION_INVALID = 0x800710CD
+        ND_NOT_SUPPORTED = 0x80070032
+
+        # Queue pair types
+        ND_QP_TYPE_SEND_RECV = 0
+        ND_QP_TYPE_RDMA = 1
+
+        # Work completion status
+        ND_CQ_SUCCESS = 0
+        ND_CQ_FLUSHED = 1
+        ND_CQ_LOCAL_ERROR = 2
+        ND_CQ_TRANSPORT_ERROR = 3
+        ND_CQ_RNR_ERROR = 4
+
+        # ND2_RESULT structure for completion queue
+        class ND2Result < FFI::Struct
+          layout :Status, :uint32,       # Completion status
+                 :BytesTransferred, :uint32,
+                 :QueuePairContext, :pointer,
+                 :RequestContext, :pointer,
+                 :RequestType, :uint32
+        end
+
+        # ND2_ADAPTER_INFO structure
+        class ND2AdapterInfo < FFI::Struct
+          layout :InfoVersion, :uint32,
+                 :VendorId, :uint32,
+                 :DeviceId, :uint32,
+                 :AdapterId, :uint64,
+                 :MaxRegistrationSize, :size_t,
+                 :MaxWindowSize, :size_t,
+                 :MaxSgeCount, :uint32,
+                 :MaxReadQueueDepth, :uint32,
+                 :MaxRecvQueueDepth, :uint32,
+                 :MaxSendQueueDepth, :uint32,
+                 :MaxCqDepth, :uint32,
+                 :MaxInlineData, :uint32,
+                 :MaxOutboundReadLimit, :uint32,
+                 :MaxInboundReadLimit, :uint32
+        end
+
+        # ND2_SGE (Scatter-Gather Entry)
+        class ND2Sge < FFI::Struct
+          layout :Buffer, :pointer,
+                 :BufferLength, :uint32,
+                 :MemoryRegionToken, :uint32
+        end
+
+        @loaded = false
+
+        def self.ensure_loaded!
+          return if @loaded
+
+          begin
+            # NetworkDirect provider DLL (from Mellanox WinOF-2 or similar)
+            # Standard locations for RDMA providers
+            ffi_lib [
+              "nd",
+              "NetworkDirect",
+              "mlx5nd",  # Mellanox ConnectX-5+
+              "mlx4nd"   # Older Mellanox
+            ]
+            attach_nd_functions!
+            @loaded = true
+          rescue FFI::NotFoundError => e
+            # Not an error if hardware not present
+            @loaded = false
+            @load_error = e.message
+          end
+        end
+
+        def self.available?
+          ensure_loaded!
+          @loaded
+        end
+
+        def self.load_error
+          @load_error
+        end
+
+        def self.attach_nd_functions!
+          # Provider enumeration
+          attach_function :NdOpenAdapter, [
+            :pointer,   # const ND2_ADAPTER_ADDRESS* pAddress
+            :uint32,    # DWORD cbAddressLength
+            :pointer    # IND2Adapter** ppAdapter (output)
+          ], :int32
+
+          # Query adapters
+          attach_function :NdQueryAddressList, [
+            :uint32,    # DWORD Flags
+            :pointer,   # ND2_ADAPTER_ADDRESS* pAddressList
+            :pointer    # DWORD* pcbAddressList (in/out)
+          ], :int32
+
+          # Provider initialization
+          attach_function :NdStartup, [:uint16], :int32   # Version
+          attach_function :NdCleanup, [], :int32
+        end
+
+        # Check status and raise on error
+        def self.check_status!(status, context = "NetworkDirect operation")
+          return if status == ND_SUCCESS
+
+          error_name = case status
+                       when ND_TIMEOUT then "ND_TIMEOUT"
+                       when ND_PENDING then "ND_PENDING"
+                       when ND_NO_MEMORY then "ND_NO_MEMORY"
+                       when ND_DEVICE_NOT_READY then "ND_DEVICE_NOT_READY"
+                       when ND_CONNECTION_REFUSED then "ND_CONNECTION_REFUSED"
+                       when ND_CONNECTION_ABORTED then "ND_CONNECTION_ABORTED"
+                       when ND_NOT_SUPPORTED then "ND_NOT_SUPPORTED"
+                       else "UNKNOWN_ERROR"
+                       end
+
+          raise RDMAError.new("#{context}: #{error_name} (0x#{status.to_s(16)})", code: status)
+        end
+      end
+
+      # Custom RDMA error class
+      class RDMAError < StandardError
+        attr_reader :code
+
+        def initialize(message, code: nil)
+          super(message)
+          @code = code
+        end
+      end
+    end
+  end
+end