fastos/fastsocket

Features

• High-Throughput TCP/IP Implementations - Implements a high-performance socket layer designed to maximize TCP throughput and reduce system call overhead.
• Multicore Steering Engines - Distributes incoming and outgoing traffic across CPU cores using hardware and software mechanisms to maximize utilization.
• Custom Socket Implementations - Provides a high-performance replacement for the Linux kernel network stack designed for linear scalability.
• Connection Locality Encoding - Encodes the originating CPU core ID into the connection source port to automate packet delivery.
• TCP Throughput Optimizers - Reduces system call overhead and lock contention to increase total network processing capacity.
• Packet Redirection - Directs network packets to the specific CPU core where the application resides to minimize latency.
• CPU-Core Connection Affinity - Maps listen sockets and incoming connections to specific CPU cores to eliminate cross-core contention.
• Socket Sharding - Distributes listen sockets across CPU cores by intercepting event loop registration for linear scalability.
• Direct-to-Core Delivery - Implements high-performance packet delivery that routes incoming traffic directly to the waiting CPU core to minimize latency.
• Packet Steering - Routes incoming packets directly to the CPU core handling the connection to minimize cross-core latency.
• Port-Encoded Steering - Encodes the creating CPU core ID into the source port of active connections to deliver packets to the correct core.
• Network Call Interceptors - Redirects standard socket calls to optimized interfaces without requiring changes to application binaries.
• Contention-Minimizing Locking Strategies - Bypasses standard inode and dcache locks in the socket file system to prevent multicore performance bottlenecks.
• System-Call Interception - Redirects standard socket calls via a shared library to replace kernel behavior without modifying application binaries.
• Linux Network Optimizations - Improves the performance of the Linux kernel networking layer by reducing lock contention and memory overhead.
• Epoll Mapping Caches - Accelerates epoll lookups by caching mappings between files and items to avoid expensive tree traversals.
• Network Interrupt Optimizers - Optimizes the network interface by adjusting hardware queue affinity and interrupt throttle rates.
• TCP Proxies - Forwards network traffic between clients and backend servers with minimal latency using optimized sockets.
• CPU Affinity Binding - Maps network interface hardware queues to specific CPU cores to distribute interrupt processing.
• Distributed Socket Tables - Spreads listen socket registrations across multiple CPU cores to eliminate contention on a single global lock.
• Epoll Lookup Caches - Implements a cache for epoll mappings to avoid expensive tree traversals during event loop operations.
• Per-Core Memory Pools - Uses pre-allocated memory pools local to each CPU core to avoid global kernel slab allocation overhead.
• Per-Core Buffer Pools - Uses per-core pre-allocated buffer pools instead of standard kernel slabs to reduce memory allocation overhead.
• Lock-Bypass Filesystems - Circumvents standard inode and dcache locks during socket operations to prevent multicore bottlenecks.
• Multicore Workload Distribution - Binds individual worker processes to specific CPU cores to distribute connection handling across multicore hardware.

Star history