Hashing fired detectors with boost::dynamic_bitset

[draganaurosgrbic]

Hashing Syndrome Patterns with boost::dynamic_bitset

In this PR, I address a key performance bottleneck: the hashing of fired detector patterns (syndrome patterns). I introduce the use of boost::dynamic_bitset from the Boost library, a data structure that combines the memory-saving bit-packing feature of std::vector<bool> with highly optimized vectorized bit-wise operations. Crucially, boost::dynamic_bitset also provides highly optimized, built-in functions for efficiently hashing sequences of boolean elements.

---

Initial Optimization: std::vector<bool> to std::vector<char>

The initial Tesseract implementation, as documented in #25, utilized std::vector<bool> to store patterns of fired detectors and predicates that block specific errors from being added to the current error hypothesis. While std::vector<bool> optimizes memory usage by packing elements into individual bits, accessing and modifying its elements is highly inefficient due to its reliance on proxy objects that perform costly bit-wise operations (shifting, masking). Given Tesseract's frequent access and modification of these elements, this caused significant performance overheads.

In #25, I transitioned from std::vector<bool> to std::vector<char>. This change made boolean elements addressable bytes, enabling efficient and direct byte-level access. Although this increased memory footprint (as each boolean was stored as a full byte), it delivered substantial performance gains by eliminating std::vector<bool>'s proxy objects and their associated overheads for element access and modification. Speedups achieved with this initial optimization were significant:

• For Color Codes, speedups reached 17.2%-32.3%
• For Bivariate-Bicycle Codes, speedups reached 13.0%-22.3%
• For Surface Codes, speedups reached 33.4%-42.5%
• For Transversal CNOT Protocols, speedups reached 12.2%-32.4%

These significant performance gains highlight the importance of choosing appropriate data structures for boolean sequences, especially in performance-sensitive applications like Tesseract. The remarkable 42.5% speedup achieved in Surface Codes with this initial switch underscores the substantial overhead caused by unsuitable data structures. The performance gain from removing std::vector<bool>'s proxy objects and their inefficient operations far outweighed any overhead from increased memory consumption.

---

Current Bottleneck: std::vector<char> and Hashing

Following the optimizations in #25, Tesseract continued to use std::vector<char> for storing and managing patterns of fired detectors and predicates that block errors. Subsequently, PR #34 replaced and merged vectors of blocked errors into the DetectorCostTuple structure, which efficiently stores error_blocked and detectors_count as uint32_t fields (reasons explained in #34). These changes left vectors of fired detectors as the sole remaining std::vector<char> data structure in this context.

After implementing and evaluating optimizations in #25, #27, and #34, profiling Tesseract to analyze remaining bottlenecks revealed that, aside from the get_detcost function, a notable bottleneck emerged: VectorCharHash (originally VectorBoolHash). This function is responsible for hashing patterns of fired detectors to prevent re-exploring previously visited syndrome states. The implementation of VectorCharHash involved iterating through each element, byte by byte, and accumulating the hash. Even though this function saw significant speedups with the initial switch from std::vector<bool> to std::vector<char>, hashing patterns of fired detectors still consumed considerable time. Post-optimization profiling (after #25, #27, and #34) revealed that this hashing function consumed approximately 25% of decoding time in Surface Codes, 30% in Transversal CNOT Protocols, 10% in Color Codes, and 2% in Bivariate-Bicycle Codes (get_detcost remained the primary bottleneck for Bivariate-Bicycle Codes). Therefore, I decided to explore opportunities to further optimize this function and enhance the decoding speed.

---

Solution: Introducing boost::dynamic_bitset

This PR addresses the performance bottleneck of hashing fired detector patterns and mitigates the increased memory footprint from the initial switch to std::vector<char> by introducing the boost::dynamic_bitset data structure. The C++ standard library's std::bitset offers an ideal conceptual solution: memory-efficient bit-packed storage (like std::vector<bool>) combined with highly efficient and vectorized bit-wise operations. This data structure achieves efficient access and modification by employing highly optimized bit-wise operations, thereby reducing performance overhead stemming from proxy objects in std::vector<bool>. However, std::bitset requires a static size (determined at compile-time), rendering it unsuitable for Tesseract's dynamically sized syndrome patterns.

The Boost library's boost::dynamic_bitset provides the perfect solution by offering dynamic-sized bit arrays whose dimensions can be determined at runtime. This data structure brilliantly combines the memory efficiency of std::vector<bool> (by packing elements into individual bits) with the performance benefits of vectorized bit-wise operations. This is achieved by internally storing bits within contiguous memory blocks and executing vectorized bit-wise operations across all elements from the same block, thus avoiding the overheads of std::vector<bool>'s proxy objects and costly bit-wise operations. Furthermore, boost::dynamic_bitset offers highly optimized, built-in hashing functions, replacing our custom, less efficient byte-by-byte hashing and resulting in a cleaner, faster implementation.

---

Performance Evaluation: Individual Impact of Optimization

I performed two types of experiments to evaluate the achieved performance gains. First, I conducted extensive benchmarks across various code families and configurations to evaluate the individual performance gains achieved by this specific optimization. Speedups achieved include:

• For Surface Codes: 8.0%-24.7%
• For Transversal CNOT Protocols: 12.1%-26.8%
• For Color Codes: 3.6%-7.0%
• For Bivariate-Bicycle Codes: 0.5%-4.8%

These results highlight the highest impact in Surface Codes and Transversal CNOT Protocols, which aligns with the initial profiling data that showcased these code families were spending more time in the original VectorCharHash function.

---

Speedups in Surface Codes

---

Speedups in Transversal CNOT Protocols

---

Speedups in Color Codes

---

Speedups in Bivariate-Bicycle Codes

---

Performance Evaluation: Cumulative Speedup

Following the evaluation of individual performance gains, I analyzed the cumulative effect of the optimizations implemented across PRs #25, #27, and #34. The cumulative speedups achieved are:

• For Color Codes: 40.7%-54.8%
• For Bivariate-Bicycle Codes: 41.5%-80.3%
• For Surface Codes: 50.0%-62.4%
• For Transversal CNOT Protocols: 57.8%-63.6%

These results demonstrate that my optimizations achieved over 2x speedup in Color Codes, over 2.5x speedup in Surface Codes and Transversal CNOT Protocols, and over 5x speedup in Bivariate-Bicycle Codes.

---

Speedups in Color Codes

---

Speedups in Bivariate-Bicycle Codes

---

Speedups in Surface Codes

---

Speedups in Transversal CNOT Protocols

---

Conclusion

These results demonstrate that the boost::dynamic_bitset optimization significantly impacts code families where the original hashing function (VectorCharHash) was a primary bottleneck (Surface Codes and Transversal CNOT Protocols). The substantial speedups achieved in these code families validate that boost::dynamic_bitset provides demonstrably more efficient hashing and bit-wise operations. For code families where hashing was less of a bottleneck (Color Codes and Bivariate-Bicycle Codes), the speedups were modest, reinforcing that std::vector<char> can remain highly efficient even with increased memory usage when bit packing is not the primary performance concern. Crucially, this optimization delivers comparable or superior performance to std::vector<char> while simultaneously reducing memory footprint, providing additional speedups where hashing performance is critical.

---

Key Contributions

• Identified the hashing of syndrome patterns as the primary remaining bottleneck in Surface Codes and Transversal CNOT Protocols, post prior optimizations (Replace std::vector<bool> with std::vector<char> for faster computations #25, Removing unnecessary std::vector copy operations #27, Accelerating 'get_detcost' function #34).
• Adopted boost::dynamic_bitset as a superior data structure, combining std::vector<bool>'s memory efficiency with high-performance vectorized bit-wise operations and efficient built-in hashing
• Replaced std::vector<char> with boost::dynamic_bitset for storing syndrome patterns.
• Performed extensive benchmarking to evaluate both the individual impact of this optimization and its cumulative effect with prior PRs.
• Achieved significant individual speedups (e.g., 8.0%-24.7% in Surface Codes, 12.1%-26.8% in Transversal CNOT Protocols) and substantial cumulative speedups (over 2x in Color Codes, over 2.5x in Surface Codes and Transversal CNOT Protocols, and over 5x in Bivariate-Bicycle Codes).

[LalehB]

LGTM!