Workiva/go-datastructures

Features

• Concurrent Data Structures - Ships a comprehensive collection of thread-safe and lock-free data structures for high-performance concurrent Go applications.
• Hash Array Mapped Tries - Provides hash array mapped tries that optimize memory and enable fast lookups and snapshots.
• Lock-Free Map Structures - Provides a lock-free hash array mapped trie that supports linearizable snapshots of the entire data set.
• Bitmapped Sets - Provides dense and sparse bitmaps for fast bitwise comparisons and intersections between integer sets.
• Red-Black Trees - Implements a red-black binary search tree to find exact or approximate overlaps between n-dimensional ranges.
• Augmented Trees - Implements augmented red-black trees to perform n-dimensional range and intersection queries.
• Lock-Free Atomic Containers - Enables constant-time snapshots of hash array mapped tries without using locks to block access.
• Persistent Data Structures - Implements persistent data structures that preserve previous versions through branch-copying and structural sharing.
• Immutable Data Structures - Provides a suite of immutable data structures, including persistent AVL trees and hash array mapped tries.
• Concurrency Synchronization Primitives - Uses compare-and-swap atomic primitives to manage concurrent access to queues and buffers without mutexes.
• Lock-Free State Management - Implements lock-free mechanisms for managing shared memory and state synchronization across multiple threads.
• Lock-Free - Provides first-in-first-out and priority queues with non-blocking sends and safe disposal.
• Immutable Transformations - Implements thread-safe AVL trees using branch-copying techniques to preserve previous versions of the data structure.
• Priority Queues - Provides priority queues with floating-point keys and efficient decrease-key operations for graph algorithms.
• Undirected Graph Models - Implements a mutable undirected graph structure that manages vertices and edges without self-loops or parallel edges.
• Integer Hash Sets - Implements a fast hashing algorithm with linear probing to check for the presence of integers.
• Integer Tries - Provides tries that treat integers as words to execute rapid predecessor and successor queries.
• Skiplists - Implements a skiplist for storing data in an ordered sequence with logarithmic operation complexity.
• Bitmapped Integer Sets - Provides fast integer set operations and existence tracking using compressed sparse and dense bitmaps.
• Sparse Bit-Arrays - Tracks integer sets using compressed bit-fields to reduce memory overhead compared to traditional hash maps.
• B-Tree - Implements a B+ tree that leverages cache locality to improve disk-efficiency and lookup performance.
• Immutable B-Trees - Provides concurrency-focused B-trees supporting bulk operations and optional persistence.
• Unordered Unique Collection Management - Provides unordered collections of unique elements that support simultaneous concurrent reads.
• Shortest Path Algorithms - Provides high-performance shortest-path graph algorithms optimized with Fibonacci heaps.
• Range Query Structures - Detects collisions and filters points across multiple dimensions using augmented trees and sparse arrays.
• Thread-Safe State Transitions - Offers utilities and thread-safe types to coordinate safe concurrent updates across multiple threads.
• Fibonacci - Provides Fibonacci heaps with efficient decrease-key operations to optimize shortest-path graph algorithms.
• Persistent - Provides a functional persistent linked list that preserves versions through cons-style manipulation.
• Blocking Synchronization - Ships a thread-safe blocking queue with compare-and-swap operations to coordinate execution and resource cleanup.
• Shared Memory Management - Provides locks and synchronization primitives to protect shared memory accessed by multiple concurrent processes.
• Bucket Sorts - Implements a multithreaded bucket sort and symmetrical merge to accelerate large-scale sorting operations.
• Parallel - Implements multithreaded bucket sorting and symmetrical merging to accelerate the organization of massive datasets.
• Specialized Data Structures - Provides a specialized toolset of Fibonacci heaps, X-Fast tries, and B+ trees for optimized range queries and graph algorithms.
• X-Fast Tries - Provides X-Fast tries to perform rapid logarithmic-time successor and predecessor searches for integers.
• Data Structures - High-performance, thread-safe data structures.
• Data Structures - Collection of data structures.

Star history