Introducing the

Non-Blocking
Internal Binary
Search Tree
Algorithm
Explore our non-blocking, scalable algorithm that achieves fast
performance while minimizing memory overhead. Say goodbye to locked
data structures and suboptimal search times.

by Karandeep Jagpal
Related Work
1 Concurrent Search Trees

Previous concurrent search tree solutions dealt with challenges like multiple mutable fields per node
and slower search times compared to simpler structures like linked lists.

2 Mitigating Concurrent Execution Issues

Execution in parallel binary search trees may pose challenges. Contention and concurrent updates
may affect the same nodes and impact performance.

3 Limitations of Existing Solutions

Existing solutions rely on locking data structures and have suboptimal memory use. The Parallel Binary
Search Tree Algorithm presented in this paper aims to address these challenges.
Algorithm Overview
Comprehensive Performance
Enhancements
The algorithm uses optimized single-word reads,
writes, and compare-and-swap operations to achieve
fast performance.
Simple Concurrency Handling
Contention only occurs when concurrent updates
affect the same nodes, ensuring smoother
concurrent operation execution.
Non-Blocking Execution
The algorithm is non-blocking, enabling concurrent
execution and multi-threading when executing
operations.
Improved Scalability and Search
Time
The implementation of the algorithm allows for
better search performance, increased scalability and
memory optimization.
Detailed Implementation
Structures
The binary search tree algorithm
depends on specific data structures
and auxiliary data structures that
have been optimized for fast
performance and scalability.
contains(k)
The contains(k) operation checks
whether the tree contains a specific
search key. Our implementation
ensures proper concurrency handling
and correct execution.
add(k)
The add(k) operation adds a specific
key to the binary search tree. Our
implementation includes concurrency
handling and ensures correct
execution and performance
optimization.
Detailed Implementation (continued)
Optimizing Traversal

The algorithm provides traversal optimizations to enhance search times.

Our implementation includes techniques like path compression to
achieve faster search times.

1 2

remove(k)

The remove(k) operation removes a specific key from the binary search
tree. Our implementation has overcome the challenges of removing
nodes during concurrent execution and ensures performance
optimization.
Memory Management
1 Memory Optimization

The Parallel Binary Search Tree Algorithm minimizes memory overhead and optimizes usage for specific
operations.
Correctness
Non-Blocking Linearizability
The algorithm ensures non-blocking execution, allowing The implemented algorithm ensures linearizability,
operations to progress smoothly even in the presence of ensuring operations appear to take effect instantly with
concurrent updates. We discuss how our correct execution.
implementation achieves non-blocking behavior and
ensures progress.
Results
Experimental Setup
We tested the algorithm using
industry-standard hardware and
benchmark datasets that characterize
specific use-cases, ensuring accuracy
of the results we present.
Throughput
Our parallel binary search tree
algorithm outperformed alternative
solutions in terms of throughput. We
present our quantitative
measurements of performance gains
and discuss how the algorithm
outperforms other solutions.
Memory Efficiency
The implementation provides
substantial memory-efficiency gains
and minimized overheads in
comparison to other benchmarked
structures, positively impacting the
algorithm’s scalability and
performance.