awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
axboe avatar

axboe/liburing

0
View on GitHub↗
3,690 Stars·520 Forks·C·MIT·5 Aufrufe

Liburing

liburing is a C library that provides a low-level wrapper for the Linux kernel io_uring interface. It serves as a programming interface for executing non-blocking disk and network operations and abstracts the system calls required to communicate with the Linux kernel.

The library focuses on reducing system call overhead and context switching for high-throughput data processing. It implements mechanisms for shared ring buffers, zero-copy buffer registration, and fixed-file descriptor mapping to minimize internal lookup and reference counting overhead.

The project covers asynchronous input and output management for both network programming and disk operations. It utilizes submission queue polling and completion queue event-loops to handle concurrent tasks without blocking.

Features

  • io_uring Async IO - Serves as a low-level wrapper for the Linux io_uring interface to perform high-performance asynchronous system calls.
  • Disk IO Optimization - Provides asynchronous disk I/O operations to maximize throughput and prevent application blocking on hardware latency.
  • Kernel-Userspace Shared Memory - Implements shared memory regions between user space and kernel space to exchange IO requests and completions without copying.
  • Asynchronous I/O Libraries - Provides a high-level interface for executing non-blocking system I/O operations via kernel ring buffers.
  • High-Performance System IO Libraries - Implements a high-performance C library designed to minimize system call overhead for high-throughput data processing.
  • Kernel API Wrappers - Provides a set of helper functions that abstract the complex system calls required to communicate with the Linux kernel.
  • Unified IO Interfaces - Provides a unified programming interface for executing non-blocking disk and network operations.
  • User-Space Submission Rings - Manages a circular submission ring in user space to efficiently stage and send requests to the kernel.
  • Asynchronous Network Programming - Enables high-concurrency network programming by handling multiple socket operations asynchronously without blocking.
  • System Call Optimizations - Reduces context switching overhead by batching system operations through shared ring buffers.
  • Submission Queue Polling - Enables the kernel to poll for new submission queue entries, eliminating the need for frequent system calls.
  • Completion Queue Polling - Implements a completion queue event-loop to monitor and notify the application of finished asynchronous operations.
  • Fixed Descriptor Registration - Provides fixed-file descriptor mapping to reduce internal lookup and reference counting overhead during I/O.
  • Zero-Copy Buffers - Supports zero-copy buffer registration to eliminate data copying during transfers between user and kernel space.

Star-Verlauf

Star-Verlauf für axboe/liburingStar-Verlauf für axboe/liburing

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI

Open-Source-Alternativen zu Liburing

Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit Liburing.
  • monoio-rs/monoioAvatar von monoio-rs

    monoio-rs/monoio

    5,033Auf GitHub ansehen↗

    monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency model that pins tasks to specific CPU cores to eliminate synchronization overhead and data migration. The runtime leverages the io_uring interface to perform non-blocking system calls and reduce kernel-user mode memory copying. It utilizes a high-performance I/O driver and zero-copy TCP stream wrapping to manage data transfer via shared-memory buffers. The project provides capabilities for CPU core affinity management, low-latency system programming, and high-performance netwo

    Rust
    Auf GitHub ansehen↗5,033
  • lewissbaker/cppcoroAvatar von lewissbaker

    lewissbaker/cppcoro

    3,818Auf GitHub ansehen↗

    cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop. The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution. Its capab

    C++asyncasync-awaitasynchronous-programming
    Auf GitHub ansehen↗3,818
  • tokio-rs/tokio-uringAvatar von tokio-rs

    tokio-rs/tokio-uring

    1,474Auf GitHub ansehen↗

    Tokio-uring is an asynchronous runtime for Rust that provides a framework for high-performance, non-blocking input and output operations. By integrating directly with the Linux kernel interface, it enables applications to offload heavy data transfer tasks to the operating system, maintaining responsiveness while managing concurrent tasks through a specialized asynchronous executor. The framework distinguishes itself by utilizing kernel-level submission and completion queues to facilitate data transfers. It employs zero-copy techniques and pre-allocated memory buffer pools, which allow data to

    Rust
    Auf GitHub ansehen↗1,474
  • chriskohlhoff/asioAvatar von chriskohlhoff

    chriskohlhoff/asio

    5,896Auf GitHub ansehen↗

    Asio is a C++ library for performing network and low-level I/O operations using a consistent asynchronous model that avoids blocking program execution. It provides a portable, cross-platform interface for network socket communication across different operating systems, and manages multiple asynchronous operations without requiring explicit thread management or locking. The library implements a proactor-based asynchronous model where operations post completion handlers to a queue for later execution, and wraps operating system I/O multiplexing mechanisms like epoll, kqueue, IOCP, and select in

    C++
    Auf GitHub ansehen↗5,896
Alle 30 Alternativen zu Liburing anzeigen→

Häufig gestellte Fragen

Was macht axboe/liburing?

liburing is a C library that provides a low-level wrapper for the Linux kernel io_uring interface. It serves as a programming interface for executing non-blocking disk and network operations and abstracts the system calls required to communicate with the Linux kernel.

Was sind die Hauptfunktionen von axboe/liburing?

Die Hauptfunktionen von axboe/liburing sind: io_uring Async IO, Disk IO Optimization, Kernel-Userspace Shared Memory, Asynchronous I/O Libraries, High-Performance System IO Libraries, Kernel API Wrappers, Unified IO Interfaces, User-Space Submission Rings.

Welche Open-Source-Alternativen gibt es zu axboe/liburing?

Open-Source-Alternativen zu axboe/liburing sind unter anderem: monoio-rs/monoio — monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency… lewissbaker/cppcoro — cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy… tokio-rs/tokio-uring — Tokio-uring is an asynchronous runtime for Rust that provides a framework for high-performance, non-blocking input and… libuv/libuv — libuv is a cross-platform asynchronous I/O library that provides an abstraction layer for event-driven networking,… boostorg/boost — Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides… async-rs/async-std — async-std is a Rust asynchronous runtime and non-blocking I/O library. It serves as an asynchronous standard library,…