How WEKA Helped Push the Boundaries of Computational Storage

When Linus Tech Tips set out to break the world record for calculating digits of pi, the goal of surpassing 202 trillion digits and reaching an unprecedented 300 trillion digits was nothing short of monumental. This wasn’t just a flex. It was a full-throttle stress test of modern computational hardware and software.

At the heart of making this massive feat possible was not just raw CPU horsepower or terabytes of fast NVMe drives. It was the clustered file system by WEKA that allowed the Linus Tech Tips team to stitch together massive pools of storage and compute into one cohesive, record-breaking machine.

What followed was part engineering marvel, part endurance trial, and entirely a testament to what’s possible when great hardware meets intelligent software.

We’re proud to share how WEKA helped make it happen.

The Challenge: Sustained Performance at Petabyte Scale

The calculation of π to 300 trillion digits is not just an exercise in CPU cycles. It’s a massive storage challenge. The software used in this effort, Y-Cruncher, treats storage as an extension of RAM, requiring constant, high-speed I/O throughput and ultra-low latency over extended compute sessions that can run for months.

This means the storage layer must be:

  • Extremely fast, with read/write speeds on par with local NVMe
  • Resilient, to handle hardware issues or system interruptions
  • Scalable, with the ability to pool storage from multiple servers into a single high-performance namespace

The challenge wasn’t just computational. It was architectural. The bottleneck wasn’t the CPUs. It was the storage, both in terms of capacity and speed.

The Hardware: Terabytes of Fast Storage and Beefy CPUs

To tackle this, Linus Tech Tips put together an insane hardware setup. Nine servers made up the core of the storage cluster, loaded with over 2.2 petabytes of KIOXIA high performance NVMe SSD storage including KIOXIA Enterprise NVMe SSDs and KIOXIA Data Center NVMe SSDs. The compute server was armed with four 200GBs Mellanox ConnectX-7 NICs, offering a staggering 1.6Tbps of total bandwidth. Meanwhile, each storage node had 400GBs of networking throughput.

But raw hardware alone doesn’t make a supercomputer.

Making It Work: Smart Architecture and a Bit of Creativity

Because the Linus Tech Tips team was working with a limited number of storage nodes, they had to get creative. WEKA typically recommends 19 instances for its 16+2+1 data and parity stripe configuration. With only nine servers, the team used a clever workaround. They ran two WEKA instances per server, effectively creating 18 instances across their 9-node cluster.

This allowed them to simulate the optimal configuration for high-efficiency striping and maximize usable storage capacity—all while maintaining high data durability.

This was a smart solution that allowed them to hit the most space-efficient stripe width for WEKA without needing to double their hardware footprint.

It’s not exactly a supported configuration, but it worked. And it worked well.

Initially, the cluster was running on an outdated WEKA deployment. But thanks to direct help from WEKA engineers Josh Hampton and Bob Bakh, the team was able to upgrade to a new custom WEKA image, which came pre-configured with everything they needed. This support was crucial to getting the system operational and performance-tuned.

Performance Tuning and Network Wizardry

Fine-tuning this monster of a setup required deep system-level optimizations. One of the biggest challenges was minimizing data transfer between the two CPUs on the compute server. Since cross-CPU communication can be both bandwidth-intensive and latency-prone, the team used two WEKA client containers, each pinned to cores within a single CPU.

With NUMA (non-uniform memory access) tuning, Linux taskset management, and careful core affinity mapping, they made sure that each WEKA instance only used local CPU cores and local memory. The goal: keep everything within its own CPU’s territory to reduce bottlenecks.

And it worked. The system reached over 100GB/s of read bandwidth, even peaking at 150GB/s in optimal scenarios—all while using a real file system across a networked environment. That’s faster than many local SSD setups. It’s a staggering example of what software-defined storage can do when it’s dialed in.

Key Benefits WEKA Delivered:

  • Performance at Scale: With WEKA, the system achieved sustained read speeds over 100 GB/s, peaking at over 150 GB/s—on par with local SSDs, but delivered over the network.
  • High Availability: Despite the high-pressure environment, the WEKA cluster demonstrated exceptional resilience, enabling seamless checkpointing and recovery—even in the face of multiple unexpected shutdowns.
  • Simplicity and Flexibility: WEKA’s software-defined architecture allowed the team to build a robust storage layer using off-the-shelf hardware, tailored for their needs.

This level of customization—and WEKA’s ability to adapt—was key to unlocking peak performance.

WEKA in the Real World (and the Not-So-Supported One)

WEKA is designed for large-scale, distributed data systems, Linus and team took it far outside that comfort zone—turning what’s essentially a prosumer lab into a clustered storage environment rivaling those found in national labs or hyperscalers.

And yet, WEKA held up. No drive failures, no serious I/O slowdowns, no application incompatibility. Even when power outages and cooling failures knocked the system offline (repeatedly), WEKA’s resilience allowed them to checkpoint and resume calculations. That was vital for keeping progress and data intact over a record-breaking 190-day runtime.

Not Just for Pi: WEKA for Any High-Performance Workload

While this project may have started as a fun and ambitious challenge, it also served as a public demonstration of how WEKA performs under extreme stress. Whether you’re calculating mathematical constants, training multi-billion parameter AI models, or ingesting petabytes of genomic data, the underlying requirements are the same:

  • Massive throughput
  • Linear scalability
  • Operational resilience

Support for modern, disaggregated architectures

WEKA delivers all of this in a software-only platform that runs on-prem, in the cloud, or across hybrid environments.

The Linus Tech Tips team summed it up best:

“It never gets old. You’re numb to the numbers until the numbers you’re looking at are 200 GB/s. And this is over a network with a functioning file system. It’s crazy!”

WEKA wasn’t just a utility in this project. It was a cornerstone. Without its ability to abstract and virtualize the massive pool of NVMe drives across the network, Y-Cruncher couldn’t have accessed storage fast or reliably enough to sustain the workload.

This wasn’t a use case from WEKA’s marketing deck. It was wild, unconventional, unsupported. And it worked.

Shoutout to the Collaborators

Thanks to WEKA’s own Josh and Bob for supporting the project. Many thanks to KIOXIA, Gigabyte, AMD, and Micron for hardware contributions, and to Alexander Yee, the creator of Y-Cruncher, for the software that made this nerd dream possible. Finally, kudos to Jake Tivy and the Linus Tech Tips team for achieving this huge milestone!

Ready to Push the Limits?

The 300 trillion digit pi calculation was an inspiring example of community, creativity, and cutting-edge technology coming together to do something extraordinary.

Want to see how WEKA can help your organization achieve record-breaking results?

Request a Demo