ASC25 Student Supercomputer Challenge
- When
- Feb – Apr 2025
- Event
- ASC25 Student Supercomputer Challenge
- Role
- Co-owned the m5C task with one teammate (team of 6)
- Awards
- First Prize and Most Popular Team
The competition
ASC is the largest student supercomputing competition in the world. Every year a few hundred university teams enter, and twenty-odd of them make it to the finals. ASC25's RNA task grew out of the work behind the 2023 Nobel Prize for mRNA vaccines: on a fixed amount of compute, get an m5C methylation site detection pipeline running, then make it faster, across three datasets that add up to about 340 million sequencing reads.
It sounds like serious science. But it was our first time competing, and none of us studied biology, so when the task first landed we were honestly a little unsure of ourselves.
How it went
The original project had almost no documentation. All we had was a single bash script, so the first job wasn't optimization at all. It was quietly piecing the pipeline back together. We went through the script tool by tool, working out what each one did and how they depended on each other, and found along the way that a few of the steps could simply be dropped.
Only once we really understood it did we dare touch the optimization.
Our first move was task-level parallelism. With the pipeline mapped out, it was easy to see that some tasks didn't depend on each other at all and could run at the same time. Rescheduling along those lines got us a 2.41× speedup overall.
Nothing fancy happened in this stage, yet it felt surprisingly rewarding. It was the first time we could actually feel that “understanding the pipeline” was an optimization in itself.
Looking a little deeper, the bottleneck turned out to be CPU utilization. Some of the tools had multi-core options, but under the default scheduling they came nowhere near using every core, and the machines sat idle most of the time.
So we split the work along the shape of the data. A long stretch in the middle of the pipeline lent itself to running in pieces, so we ran those shards concurrently across cores and then spread them over several nodes. Further down, a few tools didn't take well to parallelism, so we merged the shards back together and ran those steps the original way, patiently, to the end. The fiddly parts, like sending work across machines, gathering the results and resuming from checkpoints, we gradually turned into scripts as well.
From then on the pipeline held steady, and CPU utilization was pushed close to full.
Takeaways
Winning First Prize was a thrill, of course. But looking back, what mattered more than the placing was seeing HPC from the inside for the first time.
I used to think of parallelism as a trick: learn it once and you can use it anywhere. Working through this task showed me it's more of an ongoing balance between how the work is structured, what the data is like and what the hardware can do. There's no silver bullet.
The competition also taught me something that's hard to pick up anywhere else. Faced with a field you know nothing about, the best use of your time usually isn't to rush into writing code. It's to slow down and understand it first.
