Cysharp/ZLinq
ZLinq
ZLinq is a zero-allocation LINQ library and memory-efficient collection toolkit for C#. It provides a high-performance replacement for standard query operations by using value-type enumerators and pooled memory to eliminate heap allocations and reduce garbage collection overhead.
The library features a C# source generator that automatically routes standard query method calls to these zero-allocation implementations. It further accelerates data processing through a SIMD accelerated data library, using hardware vectorization for numeric aggregations and bulk operations on primitive arrays and spans.
Beyond linear collections, the toolkit includes a hierarchical data query tool for traversing tree-like structures such as JSON nodes, file systems, and scene graphs using axis-based traversal. It also covers memory management strategies including shared array renting and buffer-based result copying to maintain execution speed in memory-constrained environments.
Features
- Value-Type Enumerator Patterns - Avoids heap allocations by implementing query logic within structs that are passed by value.
- Zero-Allocation Data Processing - Provides high-performance data processing using value-type enumerators to eliminate heap allocations in memory-constrained environments.
- SIMD-Accelerated Data Processors - Utilizes wide CPU registers to maximize throughput during numeric aggregations and bulk processing.
- Hierarchical Querying - Provides specialized operators for traversing tree-like structures including JSON nodes, file systems, and scene graphs.
- Value-Type Enumerators - Transforms arrays and lists into value enumerables to support chaining operations without creating new objects.
- SIMD-Accelerated Arithmetic - Utilizes processor-specific SIMD vector instructions to accelerate numeric aggregations and primitive processing.
- Array Renting Pools - Stores query results in arrays rented from a shared pool to avoid frequent memory allocations.
- Zero-Allocation Conversions - Executes data transformations without triggering heap allocations to reduce the frequency of garbage collection.
- Direct Method Call Generation - Generates direct method calls via a source generator to bypass standard LINQ overhead and improve execution speed.
- Compile-Time Method Routing - Uses a C# source generator to automatically route standard query method calls to zero-allocation implementations.
- Zero-Allocation LINQ Implementations - Performs data transformations and filtering using LINQ without creating heap allocations to reduce garbage collection overhead.
- Memory-Efficient Collection Toolkits - Offers a memory-efficient toolkit for processing arrays and spans using pooled memory and value enumerators.
- Hardware-Level Vectorization - Accelerates mathematical and logical operations using hardware-level vectorization for supported primitive types.
- Pooled Array Materialization - Materializes results into arrays from a shared pool to minimize memory pressure and garbage collection.
- Zero-Allocation LINQ Implementations - Provides a zero-allocation replacement for standard LINQ using value-type enumerators.
- GC Reduction Strategies - Reduces garbage collection frequency and overhead by performing data queries without heap memory allocation.
- JSON Restructurings - Provides logic operators to filter nested JSON data structures and extract specific values.
- Numeric Aggregations - Calculates sums and averages using hardware acceleration to increase throughput for primitive types.
- Value-Based Enumerator Definitions - Supports defining specialized data traversal logic using a value-based enumerator pattern to prevent memory allocations.
- Object Hierarchy Navigation - Navigates parent-child relationships in scene graphs and object trees to find ancestors and descendants.
- Axis-Based Hierarchy Traversal - Implements specialized enumerators for navigating ancestor and descendant relationships in tree-like structures.
- Vectorized Data Processing - Processes array and span elements using hardware vector widths via lambda expressions for high-performance iteration.
- File System Hierarchy Querying - Enables directory and file traversal using specialized operators to locate ancestors, children, and descendants.
- Tree Traversal Utilities - Provides utilities for efficiently navigating and retrieving nodes within hierarchical structures like JSON or file systems.
- Scene Graph Hierarchy Querying - Navigates parent and child relationships within a scene graph to locate specific components or objects.
- Managed Memory Allocators - Uses value-type enumerators to remove heap allocations typically caused by standard query operations.
- Vectorized Loop Processing - Applies transformations to arrays and spans using hardware vector widths to process elements in bulk.
- C Source Generators - Uses a C# source generator to automatically route standard LINQ calls to zero-allocation implementations.
- High-Performance Method Replacements - Enables swapping standard query methods for high-performance alternatives via assembly-level configuration settings.
- Memory Spans - Processes contiguous blocks of memory using type-safe views to optimize performance and reduce allocations.
- Array Materialization Pooling - Rents temporary buffers from a shared memory pool to store query results instead of allocating new arrays.
- Custom Query Operators - Allows the implementation of user-defined query operators through enumerator structs for efficient item retrieval.
- Zero-Copy Buffers - Transfers processed elements directly into existing buffers to avoid allocating new return collections.
- Buffer-Copy Transfers - Copies processed elements directly into existing memory spans to eliminate return collection allocations.
