XLIO Ultra API

High-performance zero-copy networking interface. More...

Modules
	Initialization and Cleanup
	Functions for initializing and cleaning up the XLIO Ultra API.
	Polling Groups
	Functions for managing polling groups and event handling.
	Socket Management
	Functions for creating and managing XLIO sockets.
	Transmit Operations
	High-performance data transmission functions.
	Receive Operations
	Zero-copy receive buffer management.
	Event Callbacks
	Callback functions for handling socket events.

Detailed Description

High-performance zero-copy networking interface.

The XLIO Ultra API is a performance-oriented, event-based networking interface designed for applications requiring maximum throughput and minimal latency. It provides zero-copy capabilities and efficient memory management for high-performance networking.

Key Features

• Native zero-copy TX and RX operations
• Immediate callback-based event notification without accumulation
• Optimized data path with fewer corner cases and non-performance-oriented features
  • No blocking mode
  • No partial writes
• Simplified application development:
  • Fewer error conditions and corner cases to handle
  • Flexible control of TX data aggregation
  • High-level TX operation completion
• Concurrency and scalability:
  • No global namespace - sockets grouped by polling groups
  • Clear concurrency boundaries and scalability model
  • Each group can be handled independently by different threads

Architecture Overview

The API is built around three main concepts:

1. Polling Groups: Event management and callback registration
2. Sockets: TCP socket abstraction with zero-copy capabilities
3. Buffers: Memory management for zero-copy operations

Typical Workflow

1. Initialize XLIO with xlio_init_ex()
2. Create polling group with xlio_poll_group_create()
3. Create socket with xlio_socket_create()
4. Configure socket (bind, connect, listen)
5. Poll for events with xlio_poll_group_poll()
6. Handle events via registered callbacks
7. Send/receive data using zero-copy operations
8. Clean up resources

Concurrency and Thread Safety

The XLIO Ultra API is designed for high-performance applications with specific concurrency patterns and thread safety requirements.

Thread Safety Model

• The API is NOT thread-safe by default
• Applications are responsible for proper serialization when accessing XLIO objects from multiple threads
• No internal locking is provided to maximize performance

Polling Group Concurrency

Polling groups are the primary mechanism for achieving concurrency:

• Multiple polling groups can be polled concurrently from different threads
• Polling groups do not share resources with each other
• Sockets from different groups can be handled concurrently without serialization

Serialization Requirements

• Within a polling group: All operations require serialization
  • Only one thread should call xlio_poll_group_poll() per group at a time
  • Socket operations within the same group must be serialized
  • Serialized polling group and socket calls can be executed by different threads
• Across polling groups: No serialization required
  • Different threads can operate on different groups simultaneously

Thread Safety Exceptions

Some operations have specific thread safety characteristics:

• Initialization: xlio_init_ex() and xlio_exit() are not thread-safe
• A group created with the flag XLIO_GROUP_FLAG_SAFE can execute a polling and socket TX operations concurrently

Current Limitations

• TCP sockets only (no UDP support)
• No crypto offload support
• No bonding support
• Only busy polling is supported
• fork() is supported only without created polling groups