Workiva/go-datastructures
Go Datastructures
go-datastructures is a collection of thread-safe and lock-free data structures designed for high-performance concurrent applications in Go. It provides a modular library of specialized algorithmic toolsets, including a lock-free collection library and an immutable data structure library.
The project distinguishes itself through a suite of persistent AVL trees and hash array mapped tries that use branch-copying to preserve previous versions. It also implements non-blocking hash maps, queues, and tries that enable linearizable snapshots and concurrent updates without the use of mutual exclusion locks.
The library covers a broad range of capability areas, including dimensional indexing for range querying, graph algorithms optimized with Fibonacci heaps, and fast integer set operations using sparse bitmaps. It further includes ordered collections such as skiplists and B+ trees, as well as multithreaded bucket sorting for large datasets.
The toolset also provides synchronization primitives like thread-safe ring buffers and event broadcasting mechanisms for coordinating execution between Go routines.
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 structure implementations.
- Data Structures - Collection of data structures.
