awesome-repositories.com
Blog
MCP
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoServidor MCPAcerca deCómo clasificamosPrensa
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

29 repositorios

Awesome GitHub RepositoriesZero-Copy Memory Mappings

Techniques that map files directly into process memory to avoid redundant data copying between kernel and user space.

Explore 29 awesome GitHub repositories matching data & databases · Zero-Copy Memory Mappings. Refine with filters or upvote what's useful.

Awesome Zero-Copy Memory Mappings GitHub Repositories

Encuentra los mejores repositorios con IA.Buscaremos los repositorios que mejor coincidan usando IA.
  • meilisearch/meilisearchAvatar de meilisearch

    meilisearch/meilisearch

    58,118Ver en GitHub↗

    Meilisearch is a Rust-based search engine providing typo-tolerant full-text and vector-based semantic search with real-time conversational capabilities.

    Maps database files directly into memory to eliminate redundant data copying between kernel and user space.

    Rustaiapiapp-search
    Ver en GitHub↗58,118
  • simdjson/simdjsonAvatar de simdjson

    simdjson/simdjson

    23,260Ver en GitHub↗

    simdjson is a high-performance, header-only C++ library designed for parsing, querying, and serializing JSON data with minimal memory overhead. It functions as a hardware-aware data processing engine that leverages vector instructions to achieve gigabyte-per-second parsing speeds. By detecting host processor capabilities at runtime, the library automatically selects the most efficient instruction sets to accelerate structural analysis and validation. The library distinguishes itself through a focus on extreme efficiency and resource management. It utilizes memory mapping and padded buffer ali

    The library provides direct access to memory-mapped files or string buffers to enable efficient processing of large data structures without intermediate copies.

    C++aarch64arm64avx2
    Ver en GitHub↗23,260
  • huggingface/candleAvatar de huggingface

    huggingface/candle

    19,422Ver en GitHub↗

    Candle is a minimalist machine learning framework and deep learning inference engine designed for the Rust programming language. It functions as a low-level tensor computation library, providing the necessary primitives for multi-dimensional array operations and mathematical transformations required to execute pre-trained neural network models. The framework distinguishes itself through a focus on memory efficiency and hardware utilization. It employs static-typed tensor operations to enforce shape validation and memory safety at compile time, while utilizing a lazy-loaded computational graph

    Uses zero-copy memory mapping to access model weights directly from disk, reducing data duplication and memory footprint.

    Rust
    Ver en GitHub↗19,422
  • gfx-rs/wgpuAvatar de gfx-rs

    gfx-rs/wgpu

    17,382Ver en GitHub↗

    This project is a cross-platform graphics and compute framework that provides a unified, hardware-agnostic abstraction layer for rendering and parallel processing. It enables developers to build high-performance applications that execute consistently across diverse operating systems and hardware backends, including Vulkan, Metal, and DirectX. By mapping high-level graphics commands to native APIs, it serves as a portable foundation for both real-time 3D rendering and general-purpose GPU computing. The framework distinguishes itself through a robust architecture that supports both native deskt

    Transfers processed results from graphics memory back to the host system by mapping buffers for reading.

    Rustd3d12gpuhacktoberfest
    Ver en GitHub↗17,382
  • realm/realm-cocoaAvatar de realm

    realm/realm-cocoa

    16,608Ver en GitHub↗

    Realm-Cocoa is a NoSQL mobile database engine and reactive object database designed for local data storage on mobile devices. It serves as a non-relational alternative to Core Data and SQLite, storing data as objects rather than tables. The system functions as an encrypted local store that protects sensitive application data using encryption. It provides reactive data synchronization, allowing application objects and user interfaces to update automatically when the underlying database changes.

    Maps database files directly into memory to read data without copying bytes into the application heap.

    Objective-C
    Ver en GitHub↗16,608
  • realm/realm-swiftAvatar de realm

    realm/realm-swift

    16,608Ver en GitHub↗

    This is a mobile object database and NoSQL local data store that replaces relational tables with a schema-based model. It functions as a reactive data store, using live object observations and change notifications to trigger automatic user interface refreshes. The system provides built-in mobile cloud data synchronization to keep local datasets consistent with a remote server across multiple devices. It also includes security features for encrypted local storage, protecting sensitive on-disk data using at-rest encryption keys and fine-grained access control. Broad capabilities include object

    Uses zero-copy memory mappings to read data directly from the database map without intermediate allocations.

    Objective-C
    Ver en GitHub↗16,608
  • rui314/moldAvatar de rui314

    rui314/mold

    16,190Ver en GitHub↗

    Mold is a high-performance linker designed to replace standard system tools for the creation of executable binaries and shared libraries. It functions as a drop-in replacement for existing linkers, focusing on accelerating the final build phase of large software projects to improve developer productivity. The tool achieves its performance by utilizing multi-threaded processing to distribute the linking of object files across multiple CPU cores. It supports cross-architecture binary linking, allowing it to process compiled files for diverse platforms efficiently. By intercepting standard linke

    Maps input object files directly into the process address space to minimize data copying and reduce system call overhead.

    C++
    Ver en GitHub↗16,190
  • redpanda-data/redpandaAvatar de redpanda-data

    redpanda-data/redpanda

    12,248Ver en GitHub↗

    Redpanda is a distributed event streaming engine designed to serve as a high-performance, drop-in replacement for existing event-driven architectures. It provides a foundation for building and scaling applications that require reliable data movement, analytical querying, and strict operational compliance across both cloud and self-managed environments. The platform distinguishes itself through a shared-nothing architecture that utilizes thread-per-core execution and a non-blocking asynchronous input/output engine to maximize throughput. It maintains data consistency through a consensus-based

    Implements a zero-copy data path using memory mapping to minimize CPU cycles and memory allocation overhead.

    C++containerscppevent-driven
    Ver en GitHub↗12,248
  • openvinotoolkit/openvinoAvatar de openvinotoolkit

    openvinotoolkit/openvino

    10,414Ver en GitHub↗

    OpenVINO is an AI inference engine and model serving platform designed to execute optimized deep learning models across CPUs, GPUs, and NPUs through a unified API. It includes a model optimization toolkit for converting, quantizing, and compressing models from various frameworks, alongside a specialized generative AI runtime for large language models. The project distinguishes itself through a plugin-based hardware acceleration layer that maps neural network operations to vendor-specific drivers. It features advanced execution mechanisms such as continuous batching, speculative decoding, and

    Eliminates data duplication overhead by sharing memory buffers between the host and hardware accelerators.

    C++aicomputer-visiondeep-learning
    Ver en GitHub↗10,414
  • scylladb/seastarAvatar de scylladb

    scylladb/seastar

    9,271Ver en GitHub↗

    Seastar is a C++ server application framework and asynchronous programming library designed for building high-performance, shared-nothing server applications. It functions as a high-performance I/O engine providing direct disk and network access through a shared-nothing framework that partitions data and execution across CPU cores. The framework distinguishes itself through a thread-per-core architecture that eliminates locking and resource contention by assigning one execution thread to each physical CPU core. It implements a userspace TCP/IP stack and kernel-bypass techniques, integrating w

    Moves data directly between storage devices and application memory using DMA-based APIs for maximum efficiency.

    C++
    Ver en GitHub↗9,271
  • spacejam/sledAvatar de spacejam

    spacejam/sled

    8,928Ver en GitHub↗

    Sled is an embedded key-value store and ACID-compliant database designed for high-performance data persistence. It functions as a log-structured storage engine that organizes data using B+ trees to support efficient range queries and prefix scans. The engine implements a zero-copy data store model, utilizing epoch-based reclamation to provide direct references to cached values without memory allocations. It distinguishes itself through a combination of write-ahead logging, page cache optimizations to reduce write amplification on flash storage, and serializable transactions for atomic multi-k

    Provides direct references to cached values using epoch-based reclamation to eliminate memory allocations during reads.

    Rustb-plus-treeb-treeconcurrent
    Ver en GitHub↗8,928
  • crossbeam-rs/crossbeamAvatar de crossbeam-rs

    crossbeam-rs/crossbeam

    8,492Ver en GitHub↗

    Crossbeam is a concurrency toolkit for Rust providing low-level primitives for writing multi-threaded programs. It focuses on lock-free data structures and memory management primitives designed for shared-memory concurrent environments. The project includes a work-stealing scheduler that uses double-ended queues to balance workloads across multiple processor cores. This system enables the implementation of work-stealing deques to distribute tasks and prevent bottlenecks. The toolkit covers broader capabilities for parallel algorithm development, multi-threaded task scheduling, and general co

    Implements epoch-based reclamation to safely defer memory deletion in concurrent environments.

    Rustconcurrencydata-structureslock-free
    Ver en GitHub↗8,492
  • cloudwego/kitexAvatar de cloudwego

    cloudwego/kitex

    7,973Ver en GitHub↗

    Kitex is a high-performance remote procedure call framework for building distributed microservices in Go. It provides a communication system compatible with gRPC and Protobuf standards and includes a suite of tools for microservices governance. The framework features proxyless service mesh integration, which allows it to manage network traffic and governance directly without adding sidecar proxy latency. It optimizes data throughput through a high-performance communication library that minimizes memory copies. The system covers a broad surface of distributed capabilities, including service d

    Reduces memory overhead and increases throughput by utilizing direct memory access during codec operations.

    Goframeworkgogrpc
    Ver en GitHub↗7,973
  • cloudwego/hertzAvatar de cloudwego

    cloudwego/hertz

    7,279Ver en GitHub↗

    Hertz is a high-performance Go HTTP framework designed for building scalable microservices, RESTful APIs, and AI applications. It functions as a high-performance web server and a communication framework for microservices, utilizing non-blocking I/O and zero-copy memory management to handle high-concurrency traffic. The project distinguishes itself through a microservices communication toolkit that supports high-efficiency remote procedure calls via gRPC and Thrift protocols. It implements an asynchronous middleware engine based on an onion model, allowing for a pluggable request-response pipe

    Implements zero-copy memory management using reference counting to handle high-concurrency traffic with minimal memory overhead.

    Gogohttpmicroservices
    Ver en GitHub↗7,279
  • neuecc/messagepack-csharpAvatar de neuecc

    neuecc/MessagePack-CSharp

    6,710Ver en GitHub↗

    MessagePack-CSharp is a high-performance binary serialization library for .NET applications that converts object graphs into the MessagePack format. It functions as a C# data serialization toolkit and a polymorphic binary encoder capable of handling abstract classes and interfaces using union keys to identify concrete derived types. The library provides a binary format transcoder to transform binary data into human-readable JSON for debugging. It supports ahead-of-time formatter generation to avoid runtime overhead and implements LZ4 binary compression to reduce the size of serialized data.

    Provides high-throughput serialization by performing unsafe memory copies of primitive arrays to bypass element-by-element processing.

    C#
    Ver en GitHub↗6,710
  • ponylang/ponycAvatar de ponylang

    ponylang/ponyc

    6,133Ver en GitHub↗

    Pony is an open-source, actor-model, capabilities-secure, high performance programming language

    Manages memory through compiler-inserted reference counting driven by reference capabilities, eliminating the need for a tracing garbage collector.

    Ponyactor-modelpony-languagepony-source
    Ver en GitHub↗6,133
  • rapidsai/cumlAvatar de rapidsai

    rapidsai/cuml

    5,209Ver en GitHub↗

    cuml es una librería y framework de aprendizaje automático acelerado por GPU que utiliza CUDA para acelerar el preprocesamiento de datos tabulares y la ejecución de modelos. Proporciona un conjunto de herramientas para entrenar y desplegar modelos de clasificación, regresión y agrupamiento en GPUs de NVIDIA y clústeres de GPU. La librería está diseñada para la escalabilidad, ofreciendo un entorno de aprendizaje automático de GPU distribuido que puede repartir la computación y los datos a través de múltiples aceleradores de hardware y nodos para manejar conjuntos de datos que exceden la memoria de un solo dispositivo. Refleja las interfaces de estimador estándar para permitir el reemplazo de modelos basados en CPU con versiones aceleradas por GPU dentro de los flujos de trabajo existentes. El proyecto cubre una amplia gama de capacidades de aprendizaje automático, incluyendo aprendizaje supervisado, agrupamiento no supervisado, búsqueda de vecinos más cercanos y reducción de dimensionalidad de alta dimensión. También incluye preprocesamiento de datos tabulares acelerado por hardware para escalado y codificación de características, extracción de características de texto, análisis de series temporales y explicabilidad de predicción de modelos. Las utilidades de soporte incluyen herramientas para la generación de conjuntos de datos sintéticos, serialización del estado del modelo y el cálculo de métricas de rendimiento del modelo.

    Uses shared memory pointers and standard array interfaces to move data between libraries without expensive serialization.

    Python
    Ver en GitHub↗5,209
  • nvidia/ncclAvatar de NVIDIA

    NVIDIA/nccl

    4,816Ver en GitHub↗

    NCCL es una biblioteca de comunicación de alto rendimiento y un framework de computación distribuida en GPU diseñado para ejecutar intercambios de datos colectivos y punto a punto a través de múltiples GPUs en sistemas de uno o varios nodos. Sirve como capa de transporte RDMA para GPU y orquestador de memoria, facilitando la sincronización de gran ancho de banda de datos y gradientes de modelos para el entrenamiento e inferencia distribuida en GPU. La biblioteca se distingue por su capacidad para ejecutar primitivas de comunicación directamente desde kernels de GPU, eliminando la CPU anfitriona del camino crítico. Utiliza la selección de rutas consciente de la topología para optimizar el movimiento de datos y emplea transporte de red basado en RDMA, incluyendo InfiniBand y NVLink, para permitir el acceso a memoria de copia cero entre dispositivos a través de diferentes nodos físicos. El proyecto cubre una amplia gama de patrones de comunicación colectiva, incluyendo reducciones, broadcasts, gathers e intercambios all-to-all, junto con acceso remoto a memoria punto a punto. Proporciona una gestión integral de comunicadores para inicializar, particionar y redimensionar grupos de GPU, así como una gestión de memoria especializada para registrar buffers y coordinar memoria compartida de dispositivo. El sistema incluye un conjunto de herramientas de monitoreo y observabilidad para el seguimiento de la salud, registro de diagnósticos y monitoreo de eventos en tiempo real, así como interfaces de integración para frameworks de aprendizaje automático, CUDA graphs, MPI y Python.

    Maps user memory regions directly to network interfaces to eliminate intermediate CPU copies during data transfers.

    C++
    Ver en GitHub↗4,816
  • cysharp/memorypackAvatar de Cysharp

    Cysharp/MemoryPack

    4,598Ver en GitHub↗

    MemoryPack es una librería de serialización binaria de alto rendimiento para C# y Unity. Proporciona un pipeline de datos de cero asignaciones y un framework de evolución de esquemas diseñado para minimizar las asignaciones de memoria y la sobrecarga de codificación. El proyecto utiliza generadores de código fuente en tiempo de compilación para evitar la reflexión en tiempo de ejecución e implementa un formato binario de codificación cero para un rendimiento máximo. Se distingue por un enfoque de cero asignaciones que reutiliza instancias de objetos para reducir la presión del recolector de basura y copia el diseño de memoria de structs no gestionados directamente a flujos binarios. La librería cubre el versionado de esquemas binarios para compatibilidad hacia atrás y admite streaming de colecciones asíncronas para grandes datasets. Incluye un generador de tipos de TypeScript para sincronizar estructuras de datos entre C# y TypeScript para el intercambio de datos entre lenguajes. Las capacidades adicionales incluyen compresión de carga útil, implementaciones de formateadores personalizados y devoluciones de llamada de serialización.

    Implements high-speed serialization by copying the memory layout of blittable structs directly to the output stream.

    C#
    Ver en GitHub↗4,598
  • rkyv/rkyvAvatar de rkyv

    rkyv/rkyv

    4,267Ver en GitHub↗

    rkyv es un framework de deserialización de copia cero para Rust que proporciona un formato de serialización binaria para archivos de datos mapeables en memoria. Permite que estructuras de datos complejas se mapeen a bytes y se accedan directamente desde un búfer sin asignar nueva memoria o copiar datos. El proyecto permite la serialización de tipos polimórficos y objetos de rasgo (trait objects), manteniendo su comportamiento dinámico y estructura dentro de la forma binaria. Utiliza direccionamiento de puntero relativo y empaquetado de estructura alineado por bytes para garantizar que los datos sigan siendo válidos independientemente de dónde se carguen en la memoria. El framework cubre la persistencia de datos de alto rendimiento y la gestión de estado de baja latencia a través del mapeo directo de memoria. Proporciona mecanismos tanto para el acceso a datos de copia cero como para la reconstrucción completa del tipo de datos cuando lo requiere la aplicación.

    Maps byte buffers directly to memory addresses to enable data access without allocation or copying.

    Rustrustserializationzero-copy
    Ver en GitHub↗4,267
Ant.12Siguiente
  1. Home
  2. Data & Databases
  3. Data Engineering and Infrastructure
  4. Data Persistence and Storage
  5. Data Storage Architectures
  6. Zero-Copy Memory Mappings

Explorar subetiquetas

  • DMA-Based Zero-Copy StorageDirect movement of data between storage devices and application memory using DMA APIs to bypass intermediate copies. **Distinct from Zero-Copy Memory Mappings:** Specifically uses DMA for hardware-to-memory transfer, whereas memory mappings focus on virtual address space mapping.
  • Direct-Memory Struct CopyingTechniques for copying primitive arrays directly in memory to maximize serialization throughput. **Distinct from Zero-Copy Memory Mappings:** Distinct from Zero-Copy Memory Mappings: focuses on high-speed copying of primitive arrays rather than mapping files to memory.
  • Epoch-Based ReclamationMemory management that tracks access windows to safely reclaim memory after all readers have finished. **Distinct from Zero-Copy Memory Mappings:** Focuses on the temporal reclamation of memory for zero-copy reads, rather than the mapping of files to memory.
  • GPU-to-CPU MappersUtilities for mapping graphics memory buffers to host-accessible memory addresses. **Distinct from Zero-Copy Memory Mappings:** Distinct from Zero-Copy Memory Mappings: focuses on the specific GPU-to-CPU transfer interface rather than general file mapping.
  • Hardware Buffer Zero-CopyTechniques for passing data directly to hardware accelerator buffers to avoid CPU memory copying. **Distinct from Zero-Copy Memory Mappings:** Targets hardware accelerator (NPU/GPU) buffers specifically, whereas the parent refers to general file-to-memory mappings.
  • Memory Reference Counting1 sub-etiquetaTechniques for managing memory blocks via reference counting to avoid data duplication during processing. **Distinct from Zero-Copy Memory Mappings:** Focuses on reference counting and memory block lifecycle rather than simple file-to-memory mapping.
  • Zero-Copy CodecsCodec implementations that use direct memory access to avoid copying data during serialization and deserialization. **Distinct from Zero-Copy Memory Mappings:** Specializes zero-copy memory mappings specifically for codec operations and data throughput rather than file-to-memory mapping.