@curious_coding

PhD on high troughput bioinformatics @ ETH Zurich; IMO, ICPC, Xoogler, Rust, road-cycling, hiking, wild camping, photography https://xitter.cf/t.co/wBv2zN4F80

 Zurich
curiouscoding.nl
Joined October 2021
  • Tweets1.9K
  • Following81
  • Followers1.2K
188Media
Include

Only show posts containing:

Exclude

Hide posts containing:

Time range
-
Minimum likes
Ragnar {Groot Koerkamp} 🦋 retweeted
Mohammed Mudasser@Md_mudasserOct 22
Key takeaways from @curious_coding session at #P99CONF : 🔹 Memory access bottlenecks priority queues. 🔹 SIMD-friendly layouts beat traditional heaps. 🔹 SimdQuickHeap is up to 2× faster than radix heaps. Data layout matters! ⚡ @P99CONF @ScyllaDB #ScyllaDB
1
6
187
Live now! – at Karlsruhe, Baden-Württemberg
P99CONF
@P99CONFOct 22
Binary heaps are cache-inefficient and cause a cache miss on nearly every pop. In 20 minutes, @curious_coding dives into SimdQuickHeap and how it results in a priority queue that is up to 10x faster than binary and d-ary heaps. ow.ly/bcB951003al #ScyllaDB #P99CONF
7
277
Thursday, 6:10pm CEST! – at Birkweiler, Deutschland
ScyllaDB
@ScyllaDBOct 19
Our @P99CONF keynotes feature top engineers and system architects like @DorLaor, @curious_coding, @georg_kreuzmayr, and @reconditerose. At our free & virtual #P99CONF, you also get to interact with each of them. Join our October 21-22 event > ow.ly/3brE50ZYYCk #ScyllaDB
1
4
277
I'll be speaking at P99 later this month!
ScyllaDB
@ScyllaDBOct 8
The SimdQuickHeap recursively partitions the data until the smallest element is found, and stores the pivots and buckets between them. @curious_coding will show how this is the fastest priority queue at our free @P99CONF on Oct. 21-22. ow.ly/3S9T50ZVVby #ScyllaDB #P99CONF
1
8
565
Ragnar {Groot Koerkamp} 🦋 retweeted
Rust for Bioinformatics@rust4bioAug 29
SIMD + Rust + pattern matching = Sassy, a small, sharp tool from @curious_coding et al., for fast sequence search. Proof that you don't need a giant framework to move the needle, sometimes you just need really well-written low-level code. 🔍🦀 academic.oup.com/bioinformat…

Sassy: fuzzy searching DNA sequences using SIMD

AbstractMotivation. Approximate string matching (ASM) is the problem of finding all occurrences of a pattern in a text while allowing up to k errors. Many

academic.oup.com
10
19
1,156
Ragnar {Groot Koerkamp} 🦋 retweeted
antisense.@razoralignMay 26
Sassy: Fuzzy Searching DNA Sequences using SIMD academic.oup.com/bioinformat…
1
6
20
1,398
Replying to @curious_coding @jpelbers @heufd4
(feel free to make a gh issue with some more context)
1
26
Replying to @jpelbers @heufd4
Rick made Barbell for demultiplexing+trimming. I'm not actually sure if it supports just trimming though. It might make sense to add this to sassy directly. The hard part is choosing all the thresholds usually (# errors; dist to end; overhang cost). github.com/rickbeeloo/barbel…

GitHub - rickbeeloo/barbell: Extremely fast and accurate Nanopore demultiplexing

Extremely fast and accurate Nanopore demultiplexing - rickbeeloo/barbell

github.com
1
36
Ragnar {Groot Koerkamp} 🦋 retweeted
Samuel Lampa - Also: smllmp.bsky.social@smllmpJun 5
As said before, this is a super useful (and *fast*) tool, that we've already been using quite a bit for troubleshooting spurious primer matching and the like. Warmly recommended!
Ragnar {Groot Koerkamp} 🦋@curious_codingJun 4
To all folks dealing with biological data: do you ever need to check if your reads contain barcodes/adapters/primers/...? Or off-target matches? Sassy is the tool to use! A super fast implementation of "approximate string matching" with a grep-like CLI. curiouscoding.nl/posts/sassy…
1
2
437
Replying to @heufd4
❤️ Basically "fuzzy grep for fasta files": search fasta/fastq files for short DNA patterns to verify that they are present/absent in the data in the right places, and what kind of errors there are.
1
1
34
Reposts would be great 🙏 I really think this can be a very useful tool for many folks outside my usual bubble.
1
195
To all folks dealing with biological data: do you ever need to check if your reads contain barcodes/adapters/primers/...? Or off-target matches? Sassy is the tool to use! A super fast implementation of "approximate string matching" with a grep-like CLI. curiouscoding.nl/posts/sassy…
1
9
1
24
3,440
github.com/RagnarGrootKoerka…

GitHub - RagnarGrootKoerkamp/quickheap: The fastest priority queue

The fastest priority queue. Contribute to RagnarGrootKoerkamp/quickheap development by creating an account on GitHub.

github.com
1
66
xitter.cf/i/status/2049441073718…
Ragnar {Groot Koerkamp} 🦋@curious_codingApr 29
New preprint! The SimdQuickHeap is the fastest priority queue, by far. 2x faster than a radix heap, and up to 10x faster than binary heaps. Coauthored with Johannes Breitling and Marvin Williams.
108
OMG! By popular demand (🤗) I'm going to speak at P99 again! This time about the SimdQuickHeap preprint that just came out: the fastest priority queue by 2x (or 10x comparing to a binary heap).
P99CONF
@P99CONFMay 1
We've been working hard behind the scenes to bring you an unforgettable P99CONF 2026. Registration is now open, so take a look at who is coming back and the new speakers we have on board > p99conf.io/2026/04/01/be-par… #ScyllaDB #P99CONF
1
2
8
866
As often: the SimdQuickHeap is a conceptually very simple data structure that thus can be easily optimized using SIMD, leading to pretty big speed gains.
1
2
129
With AVX-512, the SimdQuickHeap is consistently 2x faster than the radix heap and other engineered heaps that are I/O-efficient, and up to 10x faster than the binary heap and other tree-based heaps.
Log-log time-per-operation plots for different workloads. The x-ax has increasing input sizes, and the y-ax has the normalized time per push-pop pair of operations divided by lg n. The binary heap, d-ary heap, and weak heap all slow down as n increases, while the I/O-efficient heaps all get faster. The SimdQuickHeap is 2x faster than the radix heap and up to 10x faster than the binary heap.

ALT Log-log time-per-operation plots for different workloads. The x-ax has increasing input sizes, and the y-ax has the normalized time per push-pop pair of operations divided by lg n. The binary heap, d-ary heap, and weak heap all slow down as n increases, while the I/O-efficient heaps all get faster. The SimdQuickHeap is 2x faster than the radix heap and up to 10x faster than the binary heap.

1
4
145
The data structure has some similarities to QuickSelect and is pretty simple: repeatedly partition the list of values using random pivots until the smallest is left, and store each part in its own array. New elements are compared to the pivots and pushed to the right layer.
Overview of the SimdQuickHeap data structure: a list (vector) of pivots is stored, and the elements between consecutive pivots are stored in their own bucket (also a vector). The elements in a bucket are in between the two pivots surrounding it.

ALT Overview of the SimdQuickHeap data structure: a list (vector) of pivots is stored, and the elements between consecutive pivots are stored in their own bucket (also a vector). The elements in a bucket are in between the two pivots surrounding it.

1
2
116
New preprint! The SimdQuickHeap is the fastest priority queue, by far. 2x faster than a radix heap, and up to 10x faster than binary heaps. Coauthored with Johannes Breitling and Marvin Williams.
Data Structures and Algorithms Papers@AlgorithmPapersApr 29
SimdQuickHeap: The QuickHeap Reconsidered Johannes Breitling, Ragnar Groot Koerkamp, Marvin Williams arxiv.org/abs/2604.25681 [𝚌𝚜.𝙳𝚂]
Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

ALT Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

1
4
1
18
1,290
SimdQuickHeap: The QuickHeap Reconsidered Johannes Breitling, Ragnar Groot Koerkamp, Marvin Williams arxiv.org/abs/2604.25681 [𝚌𝚜.𝙳𝚂]
Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

ALT Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

1
1
6
1,401
Load more